Merge commit 'e4bec39a139363d1ee4cf3fb15a3fe4499215e77' into 4.6

34 files changed, 1200 insertions, 297 deletions

diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index 5ee1815..cbb8fda 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -2065,6 +2065,9 @@ Q_DECLARE_TYPEINFO(long double, Q_PRIMITIVE_TYPE);
 Q_CORE_EXPORT void *qMalloc(size_t size);
 Q_CORE_EXPORT void qFree(void *ptr);
 Q_CORE_EXPORT void *qRealloc(void *ptr, size_t size);
+Q_CORE_EXPORT void *qMallocAligned(size_t size, size_t alignment);
+Q_CORE_EXPORT void *qReallocAligned(void *ptr, size_t size, size_t oldsize, size_t alignment);
+Q_CORE_EXPORT void qFreeAligned(void *ptr);
 Q_CORE_EXPORT void *qMemCopy(void *dest, const void *src, size_t n);
 Q_CORE_EXPORT void *qMemSet(void *dest, int c, size_t n);
 
diff --git a/src/corelib/global/qmalloc.cpp b/src/corelib/global/qmalloc.cpp
index a9f103c..4aab1bd 100644
--- a/src/corelib/global/qmalloc.cpp
+++ b/src/corelib/global/qmalloc.cpp
@@ -65,4 +65,62 @@ void *qRealloc(void *ptr, size_t size)
     return ::realloc(ptr, size);
 }
 
+void *qMallocAligned(size_t size, size_t alignment)
+{
+    return qReallocAligned(0, size, 0, alignment);
+}
+
+void *qReallocAligned(void *oldptr, size_t newsize, size_t oldsize, size_t alignment)
+{
+    // fake an aligned allocation
+    Q_UNUSED(oldsize);
+
+    void *actualptr = oldptr ? static_cast<void **>(oldptr)[-1] : 0;
+    if (alignment <= sizeof(void*)) {
+        // special, fast case
+        void **newptr = static_cast<void **>(qRealloc(actualptr, newsize + sizeof(void*)));
+        if (!newptr)
+            return 0;
+        if (newptr == actualptr) {
+            // realloc succeeded without reallocating
+            return oldptr;
+        }
+
+        *newptr = newptr;
+        return newptr + 1;
+    }
+
+    union { void *ptr; void **pptr; quintptr n; } real, faked;
+
+    // qMalloc returns pointers aligned at least at sizeof(size_t) boundaries
+    // but usually more (8- or 16-byte boundaries).
+    // So we overallocate by alignment-sizeof(size_t) bytes, so we're guaranteed to find a
+    // somewhere within the first alignment-sizeof(size_t) that is properly aligned.
+
+    // However, we need to store the actual pointer, so we need to allocate actually size +
+    // alignment anyway.
+
+    real.ptr = qRealloc(actualptr, newsize + alignment);
+    if (!real.ptr)
+        return 0;
+
+    faked.n = real.n + alignment;
+    faked.n &= ~(alignment - 1);
+
+    // now save the value of the real pointer at faked-sizeof(void*)
+    // by construction, alignment > sizeof(void*) and is a power of 2, so
+    // faked-sizeof(void*) is properly aligned for a pointer
+    faked.pptr[-1] = real.ptr;
+
+    return faked.ptr;
+}
+
+void qFreeAligned(void *ptr)
+{
+    if (!ptr)
+        return;
+    void **ptr2 = static_cast<void **>(ptr);
+    free(ptr2[-1]);
+}
+
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qprocess_unix.cpp b/src/corelib/io/qprocess_unix.cpp
index 99296c7..f040d16 100644
--- a/src/corelib/io/qprocess_unix.cpp
+++ b/src/corelib/io/qprocess_unix.cpp
@@ -108,6 +108,10 @@ QT_END_NAMESPACE
 
 QT_BEGIN_NAMESPACE
 
+// POSIX requires PIPE_BUF to be 512 or larger
+// so we will use 512
+static const int errorBufferMax = 512;
+
 #ifdef Q_OS_INTEGRITY
 static inline char *strdup(const char *data)
 {
@@ -752,18 +756,19 @@ void QProcessPrivate::execChild(const char *workingDir, char **path, char **argv
     }
 
     // notify failure
+    QString error = qt_error_string(errno);
 #if defined (QPROCESS_DEBUG)
-    fprintf(stderr, "QProcessPrivate::execChild() failed, notifying parent process\n");
+    fprintf(stderr, "QProcessPrivate::execChild() failed (%s), notifying parent process\n", qPrintable(error));
 #endif
-    qt_safe_write(childStartedPipe[1], "", 1);
+    qt_safe_write(childStartedPipe[1], error.data(), error.length() * sizeof(QChar));
     qt_safe_close(childStartedPipe[1]);
     childStartedPipe[1] = -1;
 }
 
 bool QProcessPrivate::processStarted()
 {
-    char c;
-    int i = qt_safe_read(childStartedPipe[0], &c, 1);
+    ushort buf[errorBufferMax];
+    int i = qt_safe_read(childStartedPipe[0], &buf, sizeof buf);
     if (startupSocketNotifier) {
         startupSocketNotifier->setEnabled(false);
         startupSocketNotifier->deleteLater();
@@ -775,6 +780,11 @@ bool QProcessPrivate::processStarted()
 #if defined (QPROCESS_DEBUG)
     qDebug("QProcessPrivate::processStarted() == %s", i <= 0 ? "true" : "false");
 #endif
+
+    // did we read an error message?
+    if (i > 0)
+        q_func()->setErrorString(QString::fromUtf16(buf, i / sizeof(QChar)));
+
     return i <= 0;
 }
 
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index f98c449..71afc5b 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -574,8 +574,8 @@ int QMetaObjectPrivate::indexOfSignalRelative(const QMetaObject **baseObject, co
     if (i >= 0 && m && m->d.superdata) {
         int conflict = m->d.superdata->indexOfMethod(signal);
         if (conflict >= 0)
-            qWarning("QMetaObject::indexOfSignal:%s: Conflict with %s::%s",
-                     m->d.stringdata, m->d.superdata->d.stringdata, signal);
+            qWarning("QMetaObject::indexOfSignal: signal %s from %s redefined in %s",
+                     signal, m->d.superdata->d.stringdata, m->d.stringdata);
     }
 #endif
     return i;
diff --git a/src/corelib/plugin/qlibrary.cpp b/src/corelib/plugin/qlibrary.cpp
index 2b463a1..6496876 100644
--- a/src/corelib/plugin/qlibrary.cpp
+++ b/src/corelib/plugin/qlibrary.cpp
@@ -659,7 +659,10 @@ bool QLibraryPrivate::isPlugin(QSettings *settings)
 #endif
             if (!pHnd) {
 #ifdef Q_OS_WIN
+                //avoid 'Bad Image' message box
+                UINT oldmode = SetErrorMode(SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
                 hTempModule = ::LoadLibraryEx((wchar_t*)QDir::toNativeSeparators(fileName).utf16(), 0, DONT_RESOLVE_DLL_REFERENCES);
+                SetErrorMode(oldmode);
 #else
 #  if defined(Q_OS_SYMBIAN)
                 //Guard against accidentally trying to load non-plugin libraries by making sure the stub exists
diff --git a/src/corelib/tools/qcontiguouscache.cpp b/src/corelib/tools/qcontiguouscache.cpp
index b0ed701..dd7cab6 100644
--- a/src/corelib/tools/qcontiguouscache.cpp
+++ b/src/corelib/tools/qcontiguouscache.cpp
@@ -56,6 +56,16 @@ void QContiguousCacheData::dump() const
 }
 #endif
 
+QContiguousCacheData *QContiguousCacheData::allocate(int size, int alignment)
+{
+    return static_cast<QContiguousCacheData *>(qMallocAligned(size, alignment));
+}
+
+void QContiguousCacheData::free(QContiguousCacheData *data)
+{
+    qFreeAligned(data);
+}
+
 /*! \class QContiguousCache
     \brief The QContiguousCache class is a template class that provides a contiguous cache.
     \ingroup tools
diff --git a/src/corelib/tools/qcontiguouscache.h b/src/corelib/tools/qcontiguouscache.h
index ad78d1f..3785938 100644
--- a/src/corelib/tools/qcontiguouscache.h
+++ b/src/corelib/tools/qcontiguouscache.h
@@ -62,6 +62,15 @@ struct Q_CORE_EXPORT QContiguousCacheData
     int start;
     int offset;
     uint sharable : 1;
+    uint reserved : 31;
+
+    // total is 24 bytes (HP-UX aCC: 40 bytes)
+    // the next entry is already aligned to 8 bytes
+    // there will be an 8 byte gap here if T requires 16-byte alignment
+    //  (such as long double on 64-bit platforms, __int128, __float128)
+
+    static QContiguousCacheData *allocate(int size, int alignment);
+    static void free(QContiguousCacheData *data);
 
 #ifdef QT_QCONTIGUOUSCACHE_DEBUG
     void dump() const;
@@ -69,33 +78,32 @@ struct Q_CORE_EXPORT QContiguousCacheData
 };
 
 template <typename T>
-struct QContiguousCacheTypedData
+struct QContiguousCacheTypedData: private QContiguousCacheData
 {
-    QBasicAtomicInt ref;
-    int alloc;
-    int count;
-    int start;
-    int offset;
-    uint sharable : 1;
-    // uint unused : 31;
-
-    // total is 24 bytes (HP-UX aCC: 40 bytes)
-    // the next entry is already aligned to 8 bytes
-    // there will be an 8 byte gap here if T requires 16-byte alignment
-    //  (such as long double on 64-bit platforms, __int128, __float128)
-
+    // private inheritance to avoid aliasing warningss
     T array[1];
+
+    static inline void free(QContiguousCacheTypedData *data) { QContiguousCacheData::free(data); }
 };
 
 template<typename T>
 class QContiguousCache {
     typedef QContiguousCacheTypedData<T> Data;
-    union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; };
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; };
 public:
+    // STL compatibility
+    typedef T value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef ptrdiff_t difference_type;
+    typedef int size_type;
+
     explicit QContiguousCache(int capacity = 0);
     QContiguousCache(const QContiguousCache<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); }
 
-    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) free(d); }
+    inline ~QContiguousCache() { if (!d) return; if (!d->ref.deref()) free(p); }
 
     inline void detach() { if (d->ref != 1) detach_helper(); }
     inline bool isDetached() const { return d->ref == 1; }
@@ -128,10 +136,10 @@ public:
     inline int firstIndex() const { return d->offset; }
     inline int lastIndex() const { return d->offset + d->count - 1; }
 
-    inline const T &first() const { Q_ASSERT(!isEmpty()); return d->array[d->start]; }
-    inline const T &last() const { Q_ASSERT(!isEmpty()); return d->array[(d->start + d->count -1) % d->alloc]; }
-    inline T &first() { Q_ASSERT(!isEmpty()); detach(); return d->array[d->start]; }
-    inline T &last() { Q_ASSERT(!isEmpty()); detach(); return d->array[(d->start + d->count -1) % d->alloc]; }
+    inline const T &first() const { Q_ASSERT(!isEmpty()); return p->array[d->start]; }
+    inline const T &last() const { Q_ASSERT(!isEmpty()); return p->array[(d->start + d->count -1) % d->alloc]; }
+    inline T &first() { Q_ASSERT(!isEmpty()); detach(); return p->array[d->start]; }
+    inline T &last() { Q_ASSERT(!isEmpty()); detach(); return p->array[(d->start + d->count -1) % d->alloc]; }
 
     void removeFirst();
     T takeFirst();
@@ -156,23 +164,32 @@ private:
         // count the padding at the end
         return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
     }
+    int alignOfTypedData() const
+    {
+#ifdef Q_ALIGNOF
+        return qMax<int>(sizeof(void*), Q_ALIGNOF(Data));
+#else
+        return 0;
+#endif
+    }
 };
 
 template <typename T>
 void QContiguousCache<T>::detach_helper()
 {
-    union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; } x;
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
 
-    x.p = malloc(d->alloc);
+    x.d = malloc(d->alloc);
     x.d->ref = 1;
     x.d->count = d->count;
     x.d->start = d->start;
     x.d->offset = d->offset;
     x.d->alloc = d->alloc;
     x.d->sharable = true;
+    x.d->reserved = 0;
 
-    T *dest = x.d->array + x.d->start;
-    T *src = d->array + d->start;
+    T *dest = x.p->array + x.d->start;
+    T *src = p->array + d->start;
     int oldcount = x.d->count;
     while (oldcount--) {
         if (QTypeInfo<T>::isComplex) {
@@ -181,15 +198,15 @@ void QContiguousCache<T>::detach_helper()
             *dest = *src;
         }
         dest++;
-        if (dest == x.d->array + x.d->alloc)
-            dest = x.d->array;
+        if (dest == x.p->array + x.d->alloc)
+            dest = x.p->array;
         src++;
-        if (src == d->array + d->alloc)
-            src = d->array;
+        if (src == p->array + d->alloc)
+            src = p->array;
     }
 
     if (!d->ref.deref())
-        free(d);
+        free(p);
     d = x.d;
 }
 
@@ -199,14 +216,14 @@ void QContiguousCache<T>::setCapacity(int asize)
     if (asize == d->alloc)
         return;
     detach();
-    union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; } x;
-    x.p = malloc(asize);
+    union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+    x.d = malloc(asize);
     x.d->alloc = asize;
     x.d->count = qMin(d->count, asize);
     x.d->offset = d->offset + d->count - x.d->count;
     x.d->start = x.d->offset % x.d->alloc;
-    T *dest = x.d->array + (x.d->start + x.d->count-1) % x.d->alloc;
-    T *src = d->array + (d->start + d->count-1) % d->alloc;
+    T *dest = x.p->array + (x.d->start + x.d->count-1) % x.d->alloc;
+    T *src = p->array + (d->start + d->count-1) % d->alloc;
     int oldcount = x.d->count;
     while (oldcount--) {
         if (QTypeInfo<T>::isComplex) {
@@ -214,15 +231,15 @@ void QContiguousCache<T>::setCapacity(int asize)
         } else {
             *dest = *src;
         }
-        if (dest == x.d->array)
-            dest = x.d->array + x.d->alloc;
+        if (dest == x.p->array)
+            dest = x.p->array + x.d->alloc;
         dest--;
-        if (src == d->array)
-            src = d->array + d->alloc;
+        if (src == p->array)
+            src = p->array + d->alloc;
         src--;
     }
     /* free old */
-    free(d);
+    free(p);
     d = x.d;
 }
 
@@ -232,24 +249,24 @@ void QContiguousCache<T>::clear()
     if (d->ref == 1) {
         if (QTypeInfo<T>::isComplex) {
             int oldcount = d->count;
-            T * i = d->array + d->start;
-            T * e = d->array + d->alloc;
+            T * i = p->array + d->start;
+            T * e = p->array + d->alloc;
             while (oldcount--) {
                 i->~T();
                 i++;
                 if (i == e)
-                    i = d->array;
+                    i = p->array;
             }
         }
         d->count = d->start = d->offset = 0;
     } else {
-        union { QContiguousCacheData *p; QContiguousCacheTypedData<T> *d; } x;
-        x.p = malloc(d->alloc);
+        union { QContiguousCacheData *d; QContiguousCacheTypedData<T> *p; } x;
+        x.d = malloc(d->alloc);
         x.d->ref = 1;
         x.d->alloc = d->alloc;
         x.d->count = x.d->start = x.d->offset = 0;
         x.d->sharable = true;
-        if (!d->ref.deref()) free(d);
+        if (!d->ref.deref()) free(p);
         d = x.d;
     }
 }
@@ -257,13 +274,13 @@ void QContiguousCache<T>::clear()
 template <typename T>
 inline QContiguousCacheData *QContiguousCache<T>::malloc(int aalloc)
 {
-    return static_cast<QContiguousCacheData *>(qMalloc(sizeOfTypedData() + (aalloc - 1) * sizeof(T)));
+    return QContiguousCacheData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
 }
 
 template <typename T>
 QContiguousCache<T>::QContiguousCache(int cap)
 {
-    p = malloc(cap);
+    d = malloc(cap);
     d->ref = 1;
     d->alloc = cap;
     d->count = d->start = d->offset = 0;
@@ -303,16 +320,16 @@ void QContiguousCache<T>::free(Data *x)
 {
     if (QTypeInfo<T>::isComplex) {
         int oldcount = d->count;
-        T * i = d->array + d->start;
-        T * e = d->array + d->alloc;
+        T * i = p->array + d->start;
+        T * e = p->array + d->alloc;
         while (oldcount--) {
             i->~T();
             i++;
             if (i == e)
-                i = d->array;
+                i = p->array;
         }
     }
-    qFree(x);
+    x->free(x);
 }
 template <typename T>
 void QContiguousCache<T>::append(const T &value)
@@ -320,10 +337,10 @@ void QContiguousCache<T>::append(const T &value)
     detach();
     if (QTypeInfo<T>::isComplex) {
         if (d->count == d->alloc)
-            (d->array + (d->start+d->count) % d->alloc)->~T();
-        new (d->array + (d->start+d->count) % d->alloc) T(value);
+            (p->array + (d->start+d->count) % d->alloc)->~T();
+        new (p->array + (d->start+d->count) % d->alloc) T(value);
     } else {
-        d->array[(d->start+d->count) % d->alloc] = value;
+        p->array[(d->start+d->count) % d->alloc] = value;
     }
 
     if (d->count == d->alloc) {
@@ -349,12 +366,12 @@ void QContiguousCache<T>::prepend(const T &value)
         d->count++;
     else
         if (d->count == d->alloc)
-            (d->array + d->start)->~T();
+            (p->array + d->start)->~T();
 
     if (QTypeInfo<T>::isComplex)
-        new (d->array + d->start) T(value);
+        new (p->array + d->start) T(value);
     else
-        d->array[d->start] = value;
+        p->array[d->start] = value;
 }
 
 template<typename T>
@@ -364,9 +381,9 @@ void QContiguousCache<T>::insert(int pos, const T &value)
     detach();
     if (containsIndex(pos)) {
         if(QTypeInfo<T>::isComplex)
-            new (d->array + pos % d->alloc) T(value);
+            new (p->array + pos % d->alloc) T(value);
         else
-            d->array[pos % d->alloc] = value;
+            p->array[pos % d->alloc] = value;
     } else if (pos == d->offset-1)
         prepend(value);
     else if (pos == d->offset+d->count)
@@ -378,18 +395,18 @@ void QContiguousCache<T>::insert(int pos, const T &value)
         d->start = pos % d->alloc;
         d->count = 1;
         if (QTypeInfo<T>::isComplex)
-            new (d->array + d->start) T(value);
+            new (p->array + d->start) T(value);
         else
-            d->array[d->start] = value;
+            p->array[d->start] = value;
     }
 }
 
 template <typename T>
 inline const T &QContiguousCache<T>::at(int pos) const
-{ Q_ASSERT_X(pos >= d->offset && pos - d->offset < d->count, "QContiguousCache<T>::at", "index out of range"); return d->array[pos % d->alloc]; }
+{ Q_ASSERT_X(pos >= d->offset && pos - d->offset < d->count, "QContiguousCache<T>::at", "index out of range"); return p->array[pos % d->alloc]; }
 template <typename T>
 inline const T &QContiguousCache<T>::operator[](int pos) const
-{ Q_ASSERT_X(pos >= d->offset && pos - d->offset < d->count, "QContiguousCache<T>::at", "index out of range"); return d->array[pos % d->alloc]; }
+{ Q_ASSERT_X(pos >= d->offset && pos - d->offset < d->count, "QContiguousCache<T>::at", "index out of range"); return p->array[pos % d->alloc]; }
 
 template <typename T>
 inline T &QContiguousCache<T>::operator[](int pos)
@@ -397,7 +414,7 @@ inline T &QContiguousCache<T>::operator[](int pos)
     detach();
     if (!containsIndex(pos))
         insert(pos, T());
-    return d->array[pos % d->alloc];
+    return p->array[pos % d->alloc];
 }
 
 template <typename T>
@@ -407,7 +424,7 @@ inline void QContiguousCache<T>::removeFirst()
     detach();
     d->count--;
     if (QTypeInfo<T>::isComplex)
-        (d->array + d->start)->~T();
+        (p->array + d->start)->~T();
     d->start = (d->start + 1) % d->alloc;
     d->offset++;
 }
@@ -419,7 +436,7 @@ inline void QContiguousCache<T>::removeLast()
     detach();
     d->count--;
     if (QTypeInfo<T>::isComplex)
-        (d->array + (d->start + d->count) % d->alloc)->~T();
+        (p->array + (d->start + d->count) % d->alloc)->~T();
 }
 
 template <typename T>
diff --git a/src/corelib/tools/qhash.cpp b/src/corelib/tools/qhash.cpp
index f33aba9..c82c389 100644
--- a/src/corelib/tools/qhash.cpp
+++ b/src/corelib/tools/qhash.cpp
@@ -166,29 +166,38 @@ static int countBits(int hint)
 const int MinNumBits = 4;
 
 QHashData QHashData::shared_null = {
-    0, 0, Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, MinNumBits, 0, 0, true
+    0, 0, Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, MinNumBits, 0, 0, true, false, 0
 };
 
 void *QHashData::allocateNode()
 {
-    void *ptr = qMalloc(nodeSize);
+    return allocateNode(0);
+}
+
+void *QHashData::allocateNode(int nodeAlign)
+{
+    void *ptr = strictAlignment ? qMallocAligned(nodeSize, nodeAlign) : qMalloc(nodeSize);
     Q_CHECK_PTR(ptr);
     return ptr;
 }
 
 void QHashData::freeNode(void *node)
 {
-    qFree(node);
+    if (strictAlignment)
+        qFreeAligned(node);
+    else
+        qFree(node);
 }
 
 QHashData *QHashData::detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize)
 {
-    return detach_helper( node_duplicate, 0, nodeSize );
+    return detach_helper2( node_duplicate, 0, nodeSize, 0 );
 }
 
-QHashData *QHashData::detach_helper(void (*node_duplicate)(Node *, void *),
-        void (*node_delete)(Node *),
-        int nodeSize)
+QHashData *QHashData::detach_helper2(void (*node_duplicate)(Node *, void *),
+                                     void (*node_delete)(Node *),
+                                     int nodeSize,
+                                     int nodeAlign)
 {
     union {
         QHashData *d;
@@ -204,6 +213,8 @@ QHashData *QHashData::detach_helper(void (*node_duplicate)(Node *, void *),
     d->numBits = numBits;
     d->numBuckets = numBuckets;
     d->sharable = true;
+    d->strictAlignment = nodeAlign > 8;
+    d->reserved = 0;
 
     if (numBuckets) {
         QT_TRY {
@@ -222,7 +233,7 @@ QHashData *QHashData::detach_helper(void (*node_duplicate)(Node *, void *),
             Node *oldNode = buckets[i];
             while (oldNode != this_e) {
                 QT_TRY {
-                    Node *dup = static_cast<Node *>(allocateNode());
+                    Node *dup = static_cast<Node *>(allocateNode(nodeAlign));
 
                     QT_TRY {
                         node_duplicate(oldNode, dup);
@@ -262,6 +273,7 @@ void QHashData::free_helper(void (*node_delete)(Node *))
             while (cur != this_e) {
                 Node *next = cur->next;
                 node_delete(cur);
+                freeNode(cur);
                 cur = next;
             }
         }
diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h
index b65f1d3..1918229 100644
--- a/src/corelib/tools/qhash.h
+++ b/src/corelib/tools/qhash.h
@@ -125,12 +125,15 @@ struct Q_CORE_EXPORT QHashData
     short numBits;
     int numBuckets;
     uint sharable : 1;
+    uint strictAlignment : 1;
+    uint reserved : 30;
 
-    void *allocateNode();
+    void *allocateNode(); // ### Qt5 remove me
+    void *allocateNode(int nodeAlign);
     void freeNode(void *node);
     QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize); // ### Qt5 remove me
-    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
-            int nodeSize);
+    QHashData *detach_helper2(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
+                              int nodeSize, int nodeAlign);
     void mightGrow();
     bool willGrow();
     void hasShrunk();
@@ -267,6 +270,14 @@ class QHash
         return reinterpret_cast<Node *>(node);
     }
 
+#ifdef Q_ALIGNOF
+    static inline int alignOfNode() { return qMax<int>(sizeof(void*), Q_ALIGNOF(Node)); }
+    static inline int alignOfDummyNode() { return qMax<int>(sizeof(void*), Q_ALIGNOF(DummyNode)); }
+#else
+    static inline int alignOfNode() { return 0; }
+    static inline int alignOfDummyNode() { return 0; }
+#endif
+
 public:
     inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); }
     inline QHash(const QHash<Key, T> &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); }
@@ -483,7 +494,7 @@ private:
     Node **findNode(const Key &key, uint *hp = 0) const;
     Node *createNode(uint h, const Key &key, const T &value, Node **nextNode);
     void deleteNode(Node *node);
-    static void deleteNode(QHashData::Node *node);
+    static void deleteNode2(QHashData::Node *node);
 
     static void duplicateNode(QHashData::Node *originalNode, void *newNode);
 };
@@ -492,12 +503,12 @@ private:
 template <class Key, class T>
 Q_INLINE_TEMPLATE void QHash<Key, T>::deleteNode(Node *node)
 {
-    deleteNode(reinterpret_cast<QHashData::Node*>(node));
+    deleteNode2(reinterpret_cast<QHashData::Node*>(node));
+    d->freeNode(node);
 }
 
-
 template <class Key, class T>
-Q_INLINE_TEMPLATE void QHash<Key, T>::deleteNode(QHashData::Node *node)
+Q_INLINE_TEMPLATE void QHash<Key, T>::deleteNode2(QHashData::Node *node)
 {
 #ifdef Q_CC_BOR
     concrete(node)->~QHashNode<Key, T>();
@@ -506,7 +517,6 @@ Q_INLINE_TEMPLATE void QHash<Key, T>::deleteNode(QHashData::Node *node)
 #else
     concrete(node)->~Node();
 #endif
-    qFree(node);
 }
 
 template <class Key, class T>
@@ -527,9 +537,9 @@ QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anex
     Node *node;
 
     if (QTypeInfo<T>::isDummy) {
-        node = reinterpret_cast<Node *>(new (d->allocateNode()) DummyNode(akey));
+        node = reinterpret_cast<Node *>(new (d->allocateNode(alignOfDummyNode())) DummyNode(akey));
     } else {
-        node = new (d->allocateNode()) Node(akey, avalue);
+        node = new (d->allocateNode(alignOfNode())) Node(akey, avalue);
     }
 
     node->h = ah;
@@ -554,7 +564,7 @@ Q_INLINE_TEMPLATE QHash<Key, T> &QHash<Key, T>::unite(const QHash<Key, T> &other
 template <class Key, class T>
 Q_OUTOFLINE_TEMPLATE void QHash<Key, T>::freeData(QHashData *x)
 {
-    x->free_helper(deleteNode);
+    x->free_helper(deleteNode2);
 }
 
 template <class Key, class T>
@@ -566,8 +576,9 @@ Q_INLINE_TEMPLATE void QHash<Key, T>::clear()
 template <class Key, class T>
 Q_OUTOFLINE_TEMPLATE void QHash<Key, T>::detach_helper()
 {
-    QHashData *x = d->detach_helper(duplicateNode, deleteNode,
-        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node));
+    QHashData *x = d->detach_helper2(duplicateNode, deleteNode2,
+        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node),
+        QTypeInfo<T>::isDummy ? alignOfDummyNode() : alignOfNode());
     if (!d->ref.deref())
         freeData(d);
     d = x;
diff --git a/src/corelib/tools/qmap.cpp b/src/corelib/tools/qmap.cpp
index 1385810..3b48c3f 100644
--- a/src/corelib/tools/qmap.cpp
+++ b/src/corelib/tools/qmap.cpp
@@ -53,11 +53,16 @@ QT_BEGIN_NAMESPACE
 QMapData QMapData::shared_null = {
     &shared_null,
     { &shared_null, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
-    Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, 0, false, true
+    Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, 0, false, true, false, 0
 };
 
 QMapData *QMapData::createData()
 {
+    return createData(0);
+}
+
+QMapData *QMapData::createData(int alignment)
+{
     QMapData *d = new QMapData;
     Q_CHECK_PTR(d);
     Node *e = reinterpret_cast<Node *>(d);
@@ -69,6 +74,8 @@ QMapData *QMapData::createData()
     d->randomBits = 0;
     d->insertInOrder = false;
     d->sharable = true;
+    d->strictAlignment = alignment > 8;
+    d->reserved = 0;
     return d;
 }
 
@@ -80,11 +87,19 @@ void QMapData::continueFreeData(int offset)
     while (cur != e) {
         prev = cur;
         cur = cur->forward[0];
-        qFree(reinterpret_cast<char *>(prev) - offset);
+        if (strictAlignment)
+            qFreeAligned(reinterpret_cast<char *>(prev) - offset);
+        else
+            qFree(reinterpret_cast<char *>(prev) - offset);
     }
     delete this;
 }
 
+QMapData::Node *QMapData::node_create(Node *update[], int offset)
+{
+    return node_create(update, offset, 0);
+}
+
 /*!
     Creates a new node inside the data structure.
 
@@ -94,10 +109,12 @@ void QMapData::continueFreeData(int offset)
     \a offset is an amount of bytes that needs to reserved just before the
     QMapData::Node structure.
 
+    \a alignment dictates the alignment for the data.
+
     \internal
     \since 4.6
 */
-QMapData::Node *QMapData::node_create(Node *update[], int offset)
+QMapData::Node *QMapData::node_create(Node *update[], int offset, int alignment)
 {
     int level = 0;
     uint mask = (1 << Sparseness) - 1;
@@ -118,7 +135,9 @@ QMapData::Node *QMapData::node_create(Node *update[], int offset)
     if (level == 3 && !insertInOrder)
         randomBits = qrand();
 
-    void *concreteNode = qMalloc(offset + sizeof(Node) + level * sizeof(Node *));
+    void *concreteNode = strictAlignment ?
+                         qMallocAligned(offset + sizeof(Node) + level * sizeof(Node *), alignment) :
+                         qMalloc(offset + sizeof(Node) + level * sizeof(Node *));
     Q_CHECK_PTR(concreteNode);
 
     Node *abstractNode = reinterpret_cast<Node *>(reinterpret_cast<char *>(concreteNode) + offset);
@@ -145,7 +164,10 @@ void QMapData::node_delete(Node *update[], int offset, Node *node)
         update[i]->forward[i] = node->forward[i];
     }
     --size;
-    qFree(reinterpret_cast<char *>(node) - offset);
+    if (strictAlignment)
+        qFreeAligned(reinterpret_cast<char *>(node) - offset);
+    else
+        qFree(reinterpret_cast<char *>(node) - offset);
 }
 
 #ifdef QT_QMAP_DEBUG
diff --git a/src/corelib/tools/qmap.h b/src/corelib/tools/qmap.h
index 688aca6..65c3d2a 100644
--- a/src/corelib/tools/qmap.h
+++ b/src/corelib/tools/qmap.h
@@ -74,10 +74,14 @@ struct Q_CORE_EXPORT QMapData
     uint randomBits;
     uint insertInOrder : 1;
     uint sharable : 1;
+    uint strictAlignment : 1;
+    uint reserved : 29;
 
-    static QMapData *createData();
+    static QMapData *createData(); // ### Qt5 remove me
+    static QMapData *createData(int alignment);
     void continueFreeData(int offset);
-    Node *node_create(Node *update[], int offset);
+    Node *node_create(Node *update[], int offset); // ### Qt5 remove me
+    Node *node_create(Node *update[], int offset, int alignment);
     void node_delete(Node *update[], int offset, Node *node);
 #ifdef QT_QMAP_DEBUG
     uint adjust_ptr(Node *node);
@@ -145,6 +149,13 @@ class QMap
     };
 
     static inline int payload() { return sizeof(PayloadNode) - sizeof(QMapData::Node *); }
+    static inline int alignment() {
+#ifdef Q_ALIGNOF
+        return qMax(sizeof(void*), Q_ALIGNOF(Node));
+#else
+        return 0;
+#endif
+    }
     static inline Node *concrete(QMapData::Node *node) {
         return reinterpret_cast<Node *>(reinterpret_cast<char *>(node) - payload());
     }
@@ -414,7 +425,7 @@ template <class Key, class T>
 Q_INLINE_TEMPLATE typename QMapData::Node *
 QMap<Key, T>::node_create(QMapData *adt, QMapData::Node *aupdate[], const Key &akey, const T &avalue)
 {
-    QMapData::Node *abstractNode = adt->node_create(aupdate, payload());
+    QMapData::Node *abstractNode = adt->node_create(aupdate, payload(), alignment());
     QT_TRY {
         Node *concreteNode = concrete(abstractNode);
         new (&concreteNode->key) Key(akey);
@@ -715,7 +726,7 @@ template <class Key, class T>
 Q_OUTOFLINE_TEMPLATE void QMap<Key, T>::detach_helper()
 {
     union { QMapData *d; QMapData::Node *e; } x;
-    x.d = QMapData::createData();
+    x.d = QMapData::createData(alignment());
     if (d->size) {
         x.d->insertInOrder = true;
         QMapData::Node *update[QMapData::LastLevel + 1];
@@ -905,7 +916,7 @@ Q_OUTOFLINE_TEMPLATE bool QMap<Key, T>::operator==(const QMap<Key, T> &other) co
 template <class Key, class T>
 Q_OUTOFLINE_TEMPLATE QMap<Key, T>::QMap(const std::map<Key, T> &other)
 {
-    d = QMapData::createData();
+    d = QMapData::createData(alignment());
     d->insertInOrder = true;
     typename std::map<Key,T>::const_iterator it = other.end();
     while (it != other.begin()) {
diff --git a/src/corelib/tools/qvector.cpp b/src/corelib/tools/qvector.cpp
index 20f3a80..8bb1074 100644
--- a/src/corelib/tools/qvector.cpp
+++ b/src/corelib/tools/qvector.cpp
@@ -45,7 +45,14 @@
 
 QT_BEGIN_NAMESPACE
 
-QVectorData QVectorData::shared_null = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, true, false };
+static inline int alignmentThreshold()
+{
+    // malloc on 32-bit platforms should return pointers that are 8-byte aligned or more
+    // while on 64-bit platforms they should be 16-byte aligned or more
+    return 2 * sizeof(void*);
+}
+
+QVectorData QVectorData::shared_null = { Q_BASIC_ATOMIC_INITIALIZER(1), 0, 0, true, false, 0 };
 
 QVectorData *QVectorData::malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init)
 {
@@ -55,6 +62,26 @@ QVectorData *QVectorData::malloc(int sizeofTypedData, int size, int sizeofT, QVe
     return p;
 }
 
+QVectorData *QVectorData::allocate(int size, int alignment)
+{
+    return static_cast<QVectorData *>(alignment > alignmentThreshold() ? qMallocAligned(size, alignment) : qMalloc(size));
+}
+
+QVectorData *QVectorData::reallocate(QVectorData *x, int newsize, int oldsize, int alignment)
+{
+    if (alignment > alignmentThreshold())
+        return static_cast<QVectorData *>(qReallocAligned(x, newsize, oldsize, alignment));
+    return static_cast<QVectorData *>(qRealloc(x, newsize));
+}
+
+void QVectorData::free(QVectorData *x, int alignment)
+{
+    if (alignment > alignmentThreshold())
+        qFreeAligned(x);
+    else
+        qFree(x);
+}
+
 int QVectorData::grow(int sizeofTypedData, int size, int sizeofT, bool excessive)
 {
     if (excessive)
diff --git a/src/corelib/tools/qvector.h b/src/corelib/tools/qvector.h
index b77b53a..7402d77 100644
--- a/src/corelib/tools/qvector.h
+++ b/src/corelib/tools/qvector.h
@@ -72,6 +72,7 @@ struct Q_CORE_EXPORT QVectorData
 #else
     uint sharable : 1;
     uint capacity : 1;
+    uint reserved : 30;
 #endif
 
     static QVectorData shared_null;
@@ -79,6 +80,9 @@ struct Q_CORE_EXPORT QVectorData
     // some debugges when the QVector is member of a class within an unnamed namespace.
     // ### Qt 5: can be removed completely. (Ralf)
     static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init);
+    static QVectorData *allocate(int size, int alignment);
+    static QVectorData *reallocate(QVectorData *old, int newsize, int oldsize, int alignment);
+    static void free(QVectorData *data, int alignment);
     static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive);
 };
 
@@ -87,6 +91,8 @@ struct QVectorTypedData : private QVectorData
 { // private inheritance as we must not access QVectorData member thought QVectorTypedData
   // as this would break strict aliasing rules. (in the case of shared_null)
     T array[1];
+
+    static inline void free(QVectorTypedData *x, int alignment) { QVectorData::free(x, alignment); }
 };
 
 class QRegion;
@@ -302,6 +308,14 @@ private:
         // count the padding at the end
         return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this);
     }
+    inline int alignOfTypedData() const
+    {
+#ifdef Q_ALIGNOF
+        return qMax<int>(sizeof(void*), Q_ALIGNOF(Data));
+#else
+        return 0;
+#endif
+    }
 };
 
 template <typename T>
@@ -373,7 +387,7 @@ QVector<T> &QVector<T>::operator=(const QVector<T> &v)
 template <typename T>
 inline QVectorData *QVector<T>::malloc(int aalloc)
 {
-    QVectorData *vectordata = static_cast<QVectorData *>(qMalloc(sizeOfTypedData() + (aalloc - 1) * sizeof(T)));
+    QVectorData *vectordata = QVectorData::allocate(sizeOfTypedData() + (aalloc - 1) * sizeof(T), alignOfTypedData());
     Q_CHECK_PTR(vectordata);
     return vectordata;
 }
@@ -420,7 +434,7 @@ void QVector<T>::free(Data *x)
         while (i-- != b)
              i->~T();
     }
-    qFree(x);
+    x->free(x, alignOfTypedData());
 }
 
 template <typename T>
@@ -459,7 +473,8 @@ void QVector<T>::realloc(int asize, int aalloc)
             }
         } else {
             QT_TRY {
-                QVectorData *mem = static_cast<QVectorData *>(qRealloc(p, sizeOfTypedData() + (aalloc - 1) * sizeof(T)));
+                QVectorData *mem = QVectorData::reallocate(d, sizeOfTypedData() + (aalloc - 1) * sizeof(T),
+                                                           sizeOfTypedData() + (d->alloc - 1) * sizeof(T), alignOfTypedData());
                 Q_CHECK_PTR(mem);
                 x.d = d = mem;
                 x.d->size = d->size;
@@ -472,6 +487,7 @@ void QVector<T>::realloc(int asize, int aalloc)
         x.d->alloc = aalloc;
         x.d->sharable = true;
         x.d->capacity = d->capacity;
+        x.d->reserved = 0;
     }
 
     if (QTypeInfo<T>::isComplex) {
diff --git a/src/dbus/dbus.pro b/src/dbus/dbus.pro
index 57c6a58..9ab3920 100644
--- a/src/dbus/dbus.pro
+++ b/src/dbus/dbus.pro
@@ -1,77 +1,87 @@
-TARGET          = QtDBus
-QPRO_PWD        = $$PWD
-QT              = core xml
-CONFIG         += link_pkgconfig
-DEFINES        += QDBUS_MAKEDLL DBUS_API_SUBJECT_TO_CHANGE
+TARGET = QtDBus
+QPRO_PWD = $$PWD
+QT = core \
+    xml
+CONFIG += link_pkgconfig
+DEFINES += QDBUS_MAKEDLL \
+    DBUS_API_SUBJECT_TO_CHANGE
 QMAKE_CXXFLAGS += $$QT_CFLAGS_DBUS
-
-contains(QT_CONFIG, dbus-linked) {
+contains(QT_CONFIG, dbus-linked) { 
     LIBS_PRIVATE += $$QT_LIBS_DBUS
-    DEFINES      += QT_LINKED_LIBDBUS
+    DEFINES += QT_LINKED_LIBDBUS
 }
 
-#INCLUDEPATH += .
-
-unix {
-   QMAKE_PKGCONFIG_DESCRIPTION = Qt DBus module
-   QMAKE_PKGCONFIG_REQUIRES = QtCore QtXml
+# INCLUDEPATH += .
+unix { 
+    QMAKE_PKGCONFIG_DESCRIPTION = Qt \
+        DBus \
+        module
+    QMAKE_PKGCONFIG_REQUIRES = QtCore \
+        QtXml
 }
-
-win32 {
-   LIBS_PRIVATE += -lws2_32 -ladvapi32 -lnetapi32 -luser32
-   CONFIG(debug, debug|release):LIBS_PRIVATE += -ldbus-1d
-   else:LIBS_PRIVATE += -ldbus-1
+win32 { 
+    LIBS_PRIVATE += -lws2_32 \
+        -ladvapi32 \
+        -lnetapi32 \
+        -luser32
+    CONFIG(debug, debug|release):LIBS_PRIVATE += -ldbus-1d
+    else:LIBS_PRIVATE += -ldbus-1
 }
-
 include(../qbase.pri)
-
-PUB_HEADERS =  qdbusargument.h \
-	       qdbusconnectioninterface.h \
-	       qdbusmacros.h \
-	       qdbuserror.h \
-	       qdbusextratypes.h \
-	       qdbusmessage.h \
-	       qdbusserver.h \
-	       qdbusconnection.h \
-	       qdbusabstractinterface.h \
-	       qdbusinterface.h \
-	       qdbusabstractadaptor.h \
-	       qdbusreply.h \
-	       qdbusmetatype.h \
-	       qdbuspendingcall.h \
-	       qdbuspendingreply.h \
-	       qdbuscontext.h
-
+PUB_HEADERS = qdbusargument.h \
+    qdbusconnectioninterface.h \
+    qdbusmacros.h \
+    qdbuserror.h \
+    qdbusextratypes.h \
+    qdbusmessage.h \
+    qdbusserver.h \
+    qdbusconnection.h \
+    qdbusabstractinterface.h \
+    qdbusinterface.h \
+    qdbusabstractadaptor.h \
+    qdbusreply.h \
+    qdbusmetatype.h \
+    qdbuspendingcall.h \
+    qdbuspendingreply.h \
+    qdbuscontext.h
 HEADERS += $$PUB_HEADERS \
-           qdbusconnection_p.h qdbusmessage_p.h \
-           qdbusinterface_p.h qdbusxmlparser_p.h qdbusabstractadaptor_p.h \
-           qdbusargument_p.h qdbusutil_p.h qdbusabstractinterface_p.h \
-	   qdbuscontext_p.h qdbusthreaddebug_p.h qdbusintegrator_p.h \
-	   qdbuspendingcall_p.h qdbus_symbols_p.h
-
-SOURCES += qdbusconnection.cpp  \
-	qdbusconnectioninterface.cpp \
-	qdbuserror.cpp		\
-	qdbusintegrator.cpp	\
-	qdbusmessage.cpp	\
-	qdbusserver.cpp		\
-	qdbusabstractinterface.cpp \
-	qdbusinterface.cpp	\
-	qdbusxmlparser.cpp	\
-	qdbusutil.cpp		\
-	qdbusintrospection.cpp	\
-	qdbusabstractadaptor.cpp \
-	qdbusinternalfilters.cpp \
-	qdbusmetaobject.cpp	\
-	qdbusxmlgenerator.cpp	\
-	qdbusmisc.cpp		\
-	qdbusargument.cpp	\
-	qdbusreply.cpp		\
-	qdbusmetatype.cpp	\
-	qdbusextratypes.cpp	\
-	qdbusmarshaller.cpp	\
-	qdbuscontext.cpp        \
-	qdbuspendingcall.cpp	\
-	qdbuspendingreply.cpp	\
-	qdbus_symbols.cpp
-
+    qdbusconnection_p.h \
+    qdbusmessage_p.h \
+    qdbusinterface_p.h \
+    qdbusxmlparser_p.h \
+    qdbusabstractadaptor_p.h \
+    qdbusargument_p.h \
+    qdbusutil_p.h \
+    qdbusabstractinterface_p.h \
+    qdbuscontext_p.h \
+    qdbusthreaddebug_p.h \
+    qdbusintegrator_p.h \
+    qdbuspendingcall_p.h \
+    qdbus_symbols_p.h \
+    qdbusservicewatcher.h
+SOURCES += qdbusconnection.cpp \
+    qdbusconnectioninterface.cpp \
+    qdbuserror.cpp \
+    qdbusintegrator.cpp \
+    qdbusmessage.cpp \
+    qdbusserver.cpp \
+    qdbusabstractinterface.cpp \
+    qdbusinterface.cpp \
+    qdbusxmlparser.cpp \
+    qdbusutil.cpp \
+    qdbusintrospection.cpp \
+    qdbusabstractadaptor.cpp \
+    qdbusinternalfilters.cpp \
+    qdbusmetaobject.cpp \
+    qdbusxmlgenerator.cpp \
+    qdbusmisc.cpp \
+    qdbusargument.cpp \
+    qdbusreply.cpp \
+    qdbusmetatype.cpp \
+    qdbusextratypes.cpp \
+    qdbusmarshaller.cpp \
+    qdbuscontext.cpp \
+    qdbuspendingcall.cpp \
+    qdbuspendingreply.cpp \
+    qdbus_symbols.cpp \
+    qdbusservicewatcher.cpp
diff --git a/src/dbus/qdbusabstractinterface.cpp b/src/dbus/qdbusabstractinterface.cpp
index 61a9d95..994da10 100644
--- a/src/dbus/qdbusabstractinterface.cpp
+++ b/src/dbus/qdbusabstractinterface.cpp
@@ -279,9 +279,17 @@ QDBusAbstractInterface::QDBusAbstractInterface(QDBusAbstractInterfacePrivate &d,
     : QDBusAbstractInterfaceBase(d, parent)
 {
     // keep track of the service owner
-    if (!d_func()->currentOwner.isEmpty())
-        QObject::connect(d_func()->connectionPrivate(), SIGNAL(serviceOwnerChanged(QString,QString,QString)),
-                         this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+    if (d.isValid &&
+        d.connection.isConnected()
+        && !d.service.isEmpty()
+        && !d.service.startsWith(QLatin1Char(':')))
+        d_func()->connection.connect(QLatin1String(DBUS_SERVICE_DBUS), // service
+                                     QString(), // path
+                                     QLatin1String(DBUS_INTERFACE_DBUS), // interface
+                                     QLatin1String("NameOwnerChanged"),
+                                     QStringList() << d.service,
+                                     QString(), // signature
+                                     this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
 }
 
 /*!
@@ -296,9 +304,17 @@ QDBusAbstractInterface::QDBusAbstractInterface(const QString &service, const QSt
                                                  con, false), parent)
 {
     // keep track of the service owner
-    if (d_func()->connection.isConnected())
-        QObject::connect(d_func()->connectionPrivate(), SIGNAL(serviceOwnerChanged(QString,QString,QString)),
-                         this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+    if (d_func()->isValid &&
+        d_func()->connection.isConnected()
+        && !service.isEmpty()
+        && !service.startsWith(QLatin1Char(':')))
+        d_func()->connection.connect(QLatin1String(DBUS_SERVICE_DBUS), // service
+                                     QString(), // path
+                                     QLatin1String(DBUS_INTERFACE_DBUS), // interface
+                                     QLatin1String("NameOwnerChanged"),
+                                     QStringList() << service,
+                                     QString(), //signature
+                                     this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
 }
 
 /*!
@@ -544,9 +560,16 @@ void QDBusAbstractInterface::connectNotify(const char *signal)
         return;
 
     QDBusConnectionPrivate *conn = d->connectionPrivate();
-    if (conn)
-        conn->connectRelay(d->service, d->currentOwner, d->path, d->interface,
+    if (conn) {
+        // do we know what our owner is?
+        QString owner;
+        if (!d->service.isEmpty() && d->currentOwner.isNull())
+            owner = QLatin1String("");
+        else
+            owner = d->currentOwner;
+        conn->connectRelay(d->service, owner, d->path, d->interface,
                            this, signal);
+    }
 }
 
 /*!
diff --git a/src/dbus/qdbusconnection.cpp b/src/dbus/qdbusconnection.cpp
index bb0d06f..d7088ff 100644
--- a/src/dbus/qdbusconnection.cpp
+++ b/src/dbus/qdbusconnection.cpp
@@ -557,42 +557,61 @@ QDBusPendingCall QDBusConnection::asyncCall(const QDBusMessage &message, int tim
 bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface,
                               const QString &name, QObject *receiver, const char *slot)
 {
-    return connect(service, path, interface, name, QString(), receiver, slot);
+    return connect(service, path, interface, name, QStringList(), QString(), receiver, slot);
 }
 
 /*!
-    Disconnects the signal specified by the \a service, \a path, \a interface and \a name parameters from
-    the slot \a slot in object \a receiver. The arguments \a service and \a path can be empty,
-    denoting a disconnection from all signals of the (\a interface, \a name) pair, from all remote
-    applications.
+    \overload
 
-    Returns true if the disconnection was successful.
+    Connects the signal to the slot \a slot in object \a
+    receiver. Unlike the previous connect() overload, this function
+    allows one to specify the parameter signature to be connected
+    using the \a signature variable. The function will then verify
+    that this signature can be delivered to the slot specified by \a
+    slot and return false otherwise.
+
+    Returns true if the connection was successful.
+
+    \note This function verifies that the signal signature matches the
+          slot's parameters, but it does not verify that the actual
+          signal exists with the given signature in the remote
+          service.
 */
-bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString &interface,
-                                 const QString &name, QObject *receiver, const char *slot)
+bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface,
+                              const QString &name, const QString &signature,
+                              QObject *receiver, const char *slot)
 {
-    return disconnect(service, path, interface, name, QString(), receiver, slot);
+    return connect(service, path, interface, name, QStringList(), signature, receiver, slot);
 }
 
 /*!
     \overload
+    \since 4.6
 
     Connects the signal to the slot \a slot in object \a
-    receiver. Unlike the other connect() overload, this function
+    receiver. Unlike the previous connect() overload, this function
     allows one to specify the parameter signature to be connected
     using the \a signature variable. The function will then verify
     that this signature can be delivered to the slot specified by \a
     slot and return false otherwise.
 
+    The \a argumentMatch parameter lists the string parameters to be matched,
+    in sequential order. Note that, to match an empty string, you need to
+    pass a QString that is empty but not null (i.e., QString("")). A null
+    QString skips matching at that position.
+
+    Returns true if the connection was successful.
+
     \note This function verifies that the signal signature matches the
           slot's parameters, but it does not verify that the actual
           signal exists with the given signature in the remote
           service.
 */
 bool QDBusConnection::connect(const QString &service, const QString &path, const QString& interface,
-                              const QString &name, const QString &signature,
+                              const QString &name, const QStringList &argumentMatch, const QString &signature,
                               QObject *receiver, const char *slot)
 {
+
     if (!receiver || !slot || !d || !d->connection)
         return false;
     if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface))
@@ -600,53 +619,57 @@ bool QDBusConnection::connect(const QString &service, const QString &path, const
     if (interface.isEmpty() && name.isEmpty())
         return false;
 
-    // check the slot
-    QDBusConnectionPrivate::SignalHook hook;
-    QString key;
-    QString name2 = name;
-    if (name2.isNull())
-        name2.detach();
-
     QString owner = d->getNameOwner(service); // we don't care if the owner is empty
-    hook.signature = signature;               // it might get started later
-    if (!d->prepareHook(hook, key, service, owner, path, interface, name, receiver, slot, 0, false))
-        return false;           // don't connect
-
-    // avoid duplicating:
+                                              // it might get started later
     QDBusWriteLocker locker(ConnectAction, d);
-    QDBusConnectionPrivate::SignalHookHash::ConstIterator it = d->signalHooks.find(key);
-    QDBusConnectionPrivate::SignalHookHash::ConstIterator end = d->signalHooks.constEnd();
-    for ( ; it != end && it.key() == key; ++it) {
-        const QDBusConnectionPrivate::SignalHook &entry = it.value();
-        if (entry.service == hook.service &&
-            entry.owner == hook.owner &&
-            entry.path == hook.path &&
-            entry.signature == hook.signature &&
-            entry.obj == hook.obj &&
-            entry.midx == hook.midx) {
-            // no need to compare the parameters if it's the same slot
-            return true;        // already there
-        }
-    }
+    return d->connectSignal(service, owner, path, interface, name, argumentMatch, signature, receiver, slot);
+}
+
+/*!
+    Disconnects the signal specified by the \a service, \a path, \a interface
+    and \a name parameters from the slot \a slot in object \a receiver. The
+    arguments must be the same as passed to the connect() function.
 
-    d->connectSignal(key, hook);
-    return true;
+    Returns true if the disconnection was successful.
+*/
+bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString &interface,
+                                 const QString &name, QObject *receiver, const char *slot)
+{
+    return disconnect(service, path, interface, name, QStringList(), QString(), receiver, slot);
 }
 
 /*!
     \overload
 
-    Disconnects the signal from the slot \a slot in object \a
-    receiver. Unlike the other disconnect() overload, this function
-    allows one to specify the parameter signature to be disconnected
-    using the \a signature variable. The function will then verify
-    that this signature is connected to the slot specified by \a slot
-    and return false otherwise.
+    Disconnects the signal specified by the \a service, \a path, \a
+    interface, \a name, and \a signature parameters from the slot \a slot in
+    object \a receiver. The arguments must be the same as passed to the
+    connect() function.
+
+    Returns true if the disconnection was successful.
 */
 bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString& interface,
                                  const QString &name, const QString &signature,
                                  QObject *receiver, const char *slot)
 {
+    return disconnect(service, path, interface, name, QStringList(), signature, receiver, slot);
+}
+
+/*!
+    \overload
+    \since 4.6
+
+    Disconnects the signal specified by the \a service, \a path, \a
+    interface, \a name, \a argumentMatch, and \a signature parameters from
+    the slot \a slot in object \a receiver. The arguments must be the same as
+    passed to the connect() function.
+
+    Returns true if the disconnection was successful.
+*/
+bool QDBusConnection::disconnect(const QString &service, const QString &path, const QString& interface,
+                                 const QString &name, const QStringList &argumentMatch, const QString &signature,
+                                 QObject *receiver, const char *slot)
+{
     if (!receiver || !slot || !d || !d->connection)
         return false;
     if (!interface.isEmpty() && !QDBusUtil::isValidInterfaceName(interface))
@@ -654,38 +677,8 @@ bool QDBusConnection::disconnect(const QString &service, const QString &path, co
     if (interface.isEmpty() && name.isEmpty())
         return false;
 
-    // check the slot
-    QDBusConnectionPrivate::SignalHook hook;
-    QString key;
-    QString name2 = name;
-    if (name2.isNull())
-        name2.detach();
-
-    QString owner = d->getNameOwner(service); // we don't care of owner is empty
-    hook.signature = signature;
-    if (!d->prepareHook(hook, key, service, owner, path, interface, name, receiver, slot, 0, false))
-        return false;           // don't disconnect
-
-    // avoid duplicating:
     QDBusWriteLocker locker(DisconnectAction, d);
-    QDBusConnectionPrivate::SignalHookHash::Iterator it = d->signalHooks.find(key);
-    QDBusConnectionPrivate::SignalHookHash::Iterator end = d->signalHooks.end();
-    for ( ; it != end && it.key() == key; ++it) {
-        const QDBusConnectionPrivate::SignalHook &entry = it.value();
-        if (entry.service == hook.service &&
-            entry.owner == hook.owner &&
-            entry.path == hook.path &&
-            entry.signature == hook.signature &&
-            entry.obj == hook.obj &&
-            entry.midx == hook.midx) {
-            // no need to compare the parameters if it's the same slot
-            d->disconnectSignal(it);
-            return true;        // it was there
-        }
-    }
-
-    // the slot was not found
-    return false;
+    return d->disconnectSignal(service, path, interface, name, argumentMatch, signature, receiver, slot);
 }
 
 /*!
@@ -1012,14 +1005,10 @@ void QDBusConnectionPrivate::setBusService(const QDBusConnection &connection)
     busService = new QDBusConnectionInterface(connection, this);
     ref.deref(); // busService has increased the refcounting to us
                  // avoid cyclic refcounting
-//    if (mode != PeerMode)
-    QObject::connect(busService, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
-                     this, SIGNAL(serviceOwnerChanged(QString,QString,QString)));
 
     QObject::connect(this, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)),
                      busService, SIGNAL(callWithCallbackFailed(QDBusError,QDBusMessage)),
                      Qt::QueuedConnection);
-
 }
 
 /*!
diff --git a/src/dbus/qdbusconnection.h b/src/dbus/qdbusconnection.h
index 85fc7c2..82ae726 100644
--- a/src/dbus/qdbusconnection.h
+++ b/src/dbus/qdbusconnection.h
@@ -132,15 +132,21 @@ public:
 
     bool connect(const QString &service, const QString &path, const QString &interface,
                  const QString &name, QObject *receiver, const char *slot);
-    bool disconnect(const QString &service, const QString &path, const QString &interface,
-                    const QString &name, QObject *receiver, const char *slot);
-
     bool connect(const QString &service, const QString &path, const QString &interface,
                  const QString &name, const QString& signature,
                  QObject *receiver, const char *slot);
+    bool connect(const QString &service, const QString &path, const QString &interface,
+                 const QString &name, const QStringList &argumentMatch, const QString& signature,
+                 QObject *receiver, const char *slot);
+
+    bool disconnect(const QString &service, const QString &path, const QString &interface,
+                    const QString &name, QObject *receiver, const char *slot);
     bool disconnect(const QString &service, const QString &path, const QString &interface,
                     const QString &name, const QString& signature,
                     QObject *receiver, const char *slot);
+    bool disconnect(const QString &service, const QString &path, const QString &interface,
+                    const QString &name, const QStringList &argumentMatch, const QString& signature,
+                    QObject *receiver, const char *slot);
 
     bool registerObject(const QString &path, QObject *object,
                         RegisterOptions options = ExportAdaptors);
diff --git a/src/dbus/qdbusconnection_p.h b/src/dbus/qdbusconnection_p.h
index ab96457..ed29e4e 100644
--- a/src/dbus/qdbusconnection_p.h
+++ b/src/dbus/qdbusconnection_p.h
@@ -154,6 +154,7 @@ public:
     typedef QMultiHash<QString, SignalHook> SignalHookHash;
     typedef QHash<QString, QDBusMetaObject* > MetaObjectHash;
     typedef QHash<QByteArray, int> MatchRefCountHash;
+    typedef QHash<QString, int> WatchedServicesHash;
 
 public:
     // public methods are entry points from other objects
@@ -175,8 +176,14 @@ public:
     QDBusPendingCallPrivate *sendWithReplyAsync(const QDBusMessage &message, int timeout = -1);
     int sendWithReplyAsync(const QDBusMessage &message, QObject *receiver,
                            const char *returnMethod, const char *errorMethod, int timeout = -1);
+    bool connectSignal(const QString &service, const QString &owner, const QString &path, const QString& interface,
+                       const QString &name, const QStringList &argumentMatch, const QString &signature,
+                       QObject *receiver, const char *slot);
     void connectSignal(const QString &key, const SignalHook &hook);
     SignalHookHash::Iterator disconnectSignal(SignalHookHash::Iterator &it);
+    bool disconnectSignal(const QString &service, const QString &path, const QString& interface,
+                          const QString &name, const QStringList &argumentMatch, const QString &signature,
+                          QObject *receiver, const char *slot);
     void registerObject(const ObjectTreeNode *node);
     void connectRelay(const QString &service, const QString &currentOwner,
                       const QString &path, const QString &interface,
@@ -264,6 +271,7 @@ public:
     QDBusError lastError;
 
     QStringList serviceNames;
+    WatchedServicesHash watchedServiceNames;
     SignalHookHash signalHooks;
     MatchRefCountHash matchRefCounts;
     ObjectTreeNode rootNode;
@@ -278,6 +286,7 @@ public:
     static bool prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key,
                             const QString &service, const QString &owner,
                             const QString &path, const QString &interface, const QString &name,
+                            const QStringList &argMatch,
                             QObject *receiver, const char *signal, int minMIdx,
                             bool buildSignature);
     static DBusHandlerResult messageFilter(DBusConnection *, DBusMessage *, void *);
diff --git a/src/dbus/qdbusconnectioninterface.cpp b/src/dbus/qdbusconnectioninterface.cpp
index 8670ed5..414d318 100644
--- a/src/dbus/qdbusconnectioninterface.cpp
+++ b/src/dbus/qdbusconnectioninterface.cpp
@@ -336,8 +336,14 @@ void QDBusConnectionInterface::connectNotify(const char *signalName)
     else if (qstrcmp(signalName, SIGNAL(serviceUnregistered(QString))) == 0)
         QDBusAbstractInterface::connectNotify(SIGNAL(NameLost(QString)));
 
-    else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0)
+    else if (qstrcmp(signalName, SIGNAL(serviceOwnerChanged(QString,QString,QString))) == 0) {
+        static bool warningPrinted = false;
+        if (!warningPrinted) {
+            qWarning("Connecting to deprecated signal QDBusConnectionInterface::serviceOwnerChanged(QString,QString,QString)");
+            warningPrinted = true;
+        }
         QDBusAbstractInterface::connectNotify(SIGNAL(NameOwnerChanged(QString,QString,QString)));
+    }
 }
 
 /*!
diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp
index fb2dd77..c7538c3 100644
--- a/src/dbus/qdbusintegrator.cpp
+++ b/src/dbus/qdbusintegrator.cpp
@@ -392,7 +392,7 @@ static void qDBusNewConnection(DBusServer *server, DBusConnection *connection, v
 
 static QByteArray buildMatchRule(const QString &service, const QString & /*owner*/,
                                  const QString &objectPath, const QString &interface,
-                                 const QString &member, const QString & /*signature*/)
+                                 const QString &member, const QStringList &argMatch, const QString & /*signature*/)
 {
     QString result = QLatin1String("type='signal',");
     QString keyValue = QLatin1String("%1='%2',");
@@ -406,6 +406,14 @@ static QByteArray buildMatchRule(const QString &service, const QString & /*owner
     if (!member.isEmpty())
         result += keyValue.arg(QLatin1String("member"), member);
 
+    // add the argument string-matching now
+    if (!argMatch.isEmpty()) {
+        keyValue = QLatin1String("arg%1='%2',");
+        for (int i = 0; i < argMatch.count(); ++i)
+            if (!argMatch.at(i).isNull())
+                result += keyValue.arg(i).arg(argMatch.at(i));
+    }
+
     result.chop(1);             // remove ending comma
     return result.toLatin1();
 }
@@ -493,6 +501,11 @@ static QObject *findChildObject(const QDBusConnectionPrivate::ObjectTreeNode *ro
     return 0;
 }
 
+static bool shouldWatchService(const QString &service)
+{
+    return !service.isEmpty() && !service.startsWith(QLatin1Char(':'));
+}
+
 extern QDBUS_EXPORT void qDBusAddSpyHook(QDBusSpyHook);
 void qDBusAddSpyHook(QDBusSpyHook hook)
 {
@@ -933,6 +946,7 @@ QDBusConnectionPrivate::QDBusConnectionPrivate(QObject *p)
     QDBusMetaTypeId::init();
 
     rootNode.flags = 0;
+    watchedServiceNames[QLatin1String(DBUS_SERVICE_DBUS)] = 1;
 
     connect(this, SIGNAL(serviceOwnerChanged(QString,QString,QString)),
             this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
@@ -1195,6 +1209,7 @@ int QDBusConnectionPrivate::findSlot(QObject* obj, const QByteArray &normalizedN
 bool QDBusConnectionPrivate::prepareHook(QDBusConnectionPrivate::SignalHook &hook, QString &key,
                                          const QString &service, const QString &owner,
                                          const QString &path, const QString &interface, const QString &name,
+                                         const QStringList &argMatch,
                                          QObject *receiver, const char *signal, int minMIdx,
                                          bool buildSignature)
 {
@@ -1235,7 +1250,7 @@ bool QDBusConnectionPrivate::prepareHook(QDBusConnectionPrivate::SignalHook &hoo
                 hook.signature += QLatin1String( QDBusMetaType::typeToSignature( hook.params.at(i) ) );
     }
 
-    hook.matchRule = buildMatchRule(service, owner, path, interface, mname, hook.signature);
+    hook.matchRule = buildMatchRule(service, owner, path, interface, mname, argMatch, hook.signature);
     return true;                // connect to this signal
 }
 
@@ -1478,7 +1493,7 @@ void QDBusConnectionPrivate::handleSignal(const QString &key, const QDBusMessage
     //qDBusDebug() << signalHooks.keys();
     for ( ; it != end && it.key() == key; ++it) {
         const SignalHook &hook = it.value();
-        if (!hook.owner.isEmpty() && hook.owner != msg.service())
+        if (!hook.owner.isNull() && hook.owner != msg.service())
             continue;
         if (!hook.path.isEmpty() && hook.path != msg.path())
             continue;
@@ -1933,6 +1948,42 @@ int QDBusConnectionPrivate::sendWithReplyAsync(const QDBusMessage &message, QObj
     return 1;
 }
 
+bool QDBusConnectionPrivate::connectSignal(const QString &service, const QString &owner,
+                                           const QString &path, const QString &interface, const QString &name,
+                                           const QStringList &argumentMatch, const QString &signature,
+                                           QObject *receiver, const char *slot)
+{
+    // check the slot
+    QDBusConnectionPrivate::SignalHook hook;
+    QString key;
+    QString name2 = name;
+    if (name2.isNull())
+        name2.detach();
+
+    hook.signature = signature;
+    if (!prepareHook(hook, key, service, owner, path, interface, name, argumentMatch, receiver, slot, 0, false))
+        return false;           // don't connect
+
+    // avoid duplicating:
+    QDBusConnectionPrivate::SignalHookHash::ConstIterator it = signalHooks.find(key);
+    QDBusConnectionPrivate::SignalHookHash::ConstIterator end = signalHooks.constEnd();
+    for ( ; it != end && it.key() == key; ++it) {
+        const QDBusConnectionPrivate::SignalHook &entry = it.value();
+        if (entry.service == hook.service &&
+            entry.owner == hook.owner &&
+            entry.path == hook.path &&
+            entry.signature == hook.signature &&
+            entry.obj == hook.obj &&
+            entry.midx == hook.midx) {
+            // no need to compare the parameters if it's the same slot
+            return true;        // already there
+        }
+    }
+
+    connectSignal(key, hook);
+    return true;
+}
+
 void QDBusConnectionPrivate::connectSignal(const QString &key, const SignalHook &hook)
 {
     signalHooks.insertMulti(key, hook);
@@ -1960,15 +2011,81 @@ void QDBusConnectionPrivate::connectSignal(const QString &key, const SignalHook
                      hook.obj->metaObject()->method(hook.midx).signature(),
                      qPrintable(qerror.name()), qPrintable(qerror.message()));
             Q_ASSERT(false);
+        } else {
+            // Successfully connected the signal
+            // Do we need to watch for this name?
+            if (shouldWatchService(hook.service)) {
+                WatchedServicesHash::Iterator it = watchedServiceNames.find(hook.service);
+                if (it != watchedServiceNames.end()) {
+                    // already watching
+                    ++it.value();
+                } else {
+                    // we need to watch for this service changing
+                    QString dbusServerService = QLatin1String(DBUS_SERVICE_DBUS);
+                    connectSignal(dbusServerService, dbusServerService, QString(), QLatin1String(DBUS_INTERFACE_DBUS),
+                                  QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
+                                  this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+                }
+            }
         }
     }
 }
 
+bool QDBusConnectionPrivate::disconnectSignal(const QString &service,
+                                              const QString &path, const QString &interface, const QString &name,
+                                              const QStringList &argumentMatch, const QString &signature,
+                                              QObject *receiver, const char *slot)
+{
+    // check the slot
+    QDBusConnectionPrivate::SignalHook hook;
+    QString key;
+    QString name2 = name;
+    if (name2.isNull())
+        name2.detach();
+
+    hook.signature = signature;
+    if (!prepareHook(hook, key, service, QString(), path, interface, name, argumentMatch, receiver, slot, 0, false))
+        return false;           // don't disconnect
+
+    // avoid duplicating:
+    QDBusConnectionPrivate::SignalHookHash::Iterator it = signalHooks.find(key);
+    QDBusConnectionPrivate::SignalHookHash::Iterator end = signalHooks.end();
+    for ( ; it != end && it.key() == key; ++it) {
+        const QDBusConnectionPrivate::SignalHook &entry = it.value();
+        if (entry.service == hook.service &&
+            //entry.owner == hook.owner &&
+            entry.path == hook.path &&
+            entry.signature == hook.signature &&
+            entry.obj == hook.obj &&
+            entry.midx == hook.midx) {
+            // no need to compare the parameters if it's the same slot
+            disconnectSignal(it);
+            return true;        // it was there
+        }
+    }
+
+    // the slot was not found
+    return false;
+}
+
 QDBusConnectionPrivate::SignalHookHash::Iterator
 QDBusConnectionPrivate::disconnectSignal(SignalHookHash::Iterator &it)
 {
     const SignalHook &hook = it.value();
 
+    WatchedServicesHash::Iterator sit = watchedServiceNames.find(hook.service);
+    if (sit != watchedServiceNames.end()) {
+        if (sit.value() == 1) {
+            watchedServiceNames.erase(sit);
+            QString dbusServerService = QLatin1String(DBUS_SERVICE_DBUS);
+            disconnectSignal(dbusServerService, QString(), QLatin1String(DBUS_INTERFACE_DBUS),
+                          QLatin1String("NameOwnerChanged"), QStringList() << hook.service, QString(),
+                          this, SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+        } else {
+            --sit.value();
+        }
+    }
+
     bool erase = false;
     MatchRefCountHash::iterator i = matchRefCounts.find(hook.matchRule);
     if (i == matchRefCounts.end()) {
@@ -2027,7 +2144,7 @@ void QDBusConnectionPrivate::connectRelay(const QString &service, const QString
     SignalHook hook;
     QString key;
 
-    if (!prepareHook(hook, key, service, owner, path, interface, QString(), receiver, signal,
+    if (!prepareHook(hook, key, service, owner, path, interface, QString(), QStringList(), receiver, signal,
                      QDBusAbstractInterface::staticMetaObject.methodCount(), true))
         return;                 // don't connect
 
@@ -2059,7 +2176,7 @@ void QDBusConnectionPrivate::disconnectRelay(const QString &service, const QStri
     SignalHook hook;
     QString key;
 
-    if (!prepareHook(hook, key, service, owner, path, interface, QString(), receiver, signal,
+    if (!prepareHook(hook, key, service, owner, path, interface, QString(), QStringList(), receiver, signal,
                      QDBusAbstractInterface::staticMetaObject.methodCount(), true))
         return;                 // don't connect
 
diff --git a/src/dbus/qdbusservicewatcher.cpp b/src/dbus/qdbusservicewatcher.cpp
new file mode 100644
index 0000000..4872732
--- /dev/null
+++ b/src/dbus/qdbusservicewatcher.cpp
@@ -0,0 +1,374 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDBus module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qdbusservicewatcher.h"
+#include "qdbusconnection.h"
+#include "qdbus_symbols_p.h"
+
+#include <QStringList>
+
+#include <private/qobject_p.h>
+
+Q_GLOBAL_STATIC_WITH_ARGS(QString, busService, (QLatin1String(DBUS_SERVICE_DBUS)))
+Q_GLOBAL_STATIC_WITH_ARGS(QString, busPath, (QLatin1String(DBUS_PATH_DBUS)))
+Q_GLOBAL_STATIC_WITH_ARGS(QString, busInterface, (QLatin1String(DBUS_INTERFACE_DBUS)))
+Q_GLOBAL_STATIC_WITH_ARGS(QString, signalName, (QLatin1String("NameOwnerChanged")))
+
+class QDBusServiceWatcherPrivate: public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QDBusServiceWatcher)
+public:
+    QDBusServiceWatcherPrivate(const QDBusConnection &c, QDBusServiceWatcher::WatchMode wm)
+        : connection(c), watchMode(wm)
+    {
+    }
+
+    QStringList servicesWatched;
+    QDBusConnection connection;
+    QDBusServiceWatcher::WatchMode watchMode;
+
+    void _q_serviceOwnerChanged(const QString &, const QString &, const QString &);
+    void setConnection(const QStringList &services, const QDBusConnection &c, QDBusServiceWatcher::WatchMode watchMode);
+
+    QStringList matchArgsForService(const QString &service);
+    void addService(const QString &service);
+    void removeService(const QString &service);
+};
+
+void QDBusServiceWatcherPrivate::_q_serviceOwnerChanged(const QString &service, const QString &oldOwner, const QString &newOwner)
+{
+    Q_Q(QDBusServiceWatcher);
+    emit q->serviceOwnerChanged(service, oldOwner, newOwner);
+    if (oldOwner.isEmpty())
+        emit q->serviceRegistered(service);
+    else if (newOwner.isEmpty())
+        emit q->serviceUnregistered(service);
+}
+
+void QDBusServiceWatcherPrivate::setConnection(const QStringList &s, const QDBusConnection &c, QDBusServiceWatcher::WatchMode wm)
+{
+    if (connection.isConnected()) {
+        // remove older rules
+        foreach (const QString &s, servicesWatched)
+            removeService(s);
+    }
+
+    connection = c;
+    watchMode = wm;
+    servicesWatched = s;
+
+    if (connection.isConnected()) {
+        // add new rules
+        foreach (const QString &s, servicesWatched)
+            addService(s);
+    }
+}
+
+QStringList QDBusServiceWatcherPrivate::matchArgsForService(const QString &service)
+{
+    QStringList matchArgs;
+    matchArgs << service;
+
+    switch (watchMode) {
+    case QDBusServiceWatcher::WatchForOwnerChange:
+        break;
+
+    case QDBusServiceWatcher::WatchForRegistration:
+        matchArgs << QString::fromLatin1("", 0);
+        break;
+
+    case QDBusServiceWatcher::WatchForUnregistration:
+        matchArgs << QString() << QString::fromLatin1("", 0);
+        break;
+    }
+    return matchArgs;
+}
+
+void QDBusServiceWatcherPrivate::addService(const QString &service)
+{
+    QStringList matchArgs = matchArgsForService(service);
+    connection.connect(*busService(), *busPath(), *busInterface(), *signalName(),
+                       matchArgs, QString(), q_func(),
+                       SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+}
+
+void QDBusServiceWatcherPrivate::removeService(const QString &service)
+{
+    QStringList matchArgs = matchArgsForService(service);
+    connection.disconnect(*busService(), *busPath(), *busInterface(), *signalName(),
+                          matchArgs, QString(), q_func(),
+                          SLOT(_q_serviceOwnerChanged(QString,QString,QString)));
+}
+
+/*!
+    \class QDBusServiceWatcher
+    \since 4.6
+    \inmodule QtDBus
+
+    \brief The QDBusServiceWatcher class allows the user to watch for a bus service change.
+
+    A QDBusServiceWatcher object can be used to notify the application about
+    an ownership change of a service name on the bus. It has three watch
+    modes:
+
+    \list
+      \o watching for service registration only
+      \o watching for service unregistration only
+      \o watching for any kind of service ownership change (the default mode)
+    \endlist
+
+    Besides being created or deleted, services may change owners without a
+    unregister/register operation happening. So the \ref serviceRegistered()
+    and \ref serviceUnregistered() signals may not be emitted if that
+    happens.
+
+    This class is more efficient than using the
+    QDBusConnectionInterface::serviceOwnerChanged() signal because it allows
+    one to receive only the signals for which the class is interested in.
+
+    \sa QDBusConnection
+*/
+
+/*!
+    \enum QDBusServiceWatcher::WatchModeFlag
+
+    QDBusServiceWatcher supports three different watch modes, which are configured by this flag:
+
+    \value WatchForRegistration watch for service registration only, ignoring
+    any signals related to other service ownership change.
+
+    \value WatchForUnregistration watch for service unregistration only,
+    ignoring any signals related to other service ownership change.
+
+    \value WatchForOwnerChange watch for any kind of service ownership
+    change.
+*/
+
+/*!
+    \property QDBusServiceWatcher::watchMode
+
+    The \c watchMode property holds the current watch mode for this
+    QDBusServiceWatcher object. The default value for this property is
+    QDBusServiceWatcher::WatchForOwnershipChange.
+*/
+
+/*!
+    \property QDBusServiceWatcher::watchedServices
+
+    The \c servicesWatched property holds the list of services watched.
+
+    Note that modifying this list with setServicesWatched() is an expensive
+    operation. If you can, prefer to change it by way of addWatchedService()
+    and removeWatchedService().
+*/
+
+/*!
+    \fn void QDBusServiceWatcher::serviceRegistered(const QString &serviceName)
+
+    This signal is emitted whenever this object detects that the service \a
+    serviceName became available on the bus.
+
+    \sa serviceUnregistered(), serviceOwnerChanged()
+*/
+
+/*!
+    \fn void QDBusServiceWatcher::serviceUnregistered(const QString &serviceName)
+
+    This signal is emitted whenever this object detects that the service \a
+    serviceName was unregistered from the bus and is no longer available.
+
+    \sa serviceRegistered(), serviceOwnerChanged()
+*/
+
+/*!
+    \fn void QDBusServiceWatcher::serviceOwnerChanged(const QString &serviceName, const QString &oldOwner, const QString &newOwner)
+
+    This signal is emitted whenever this object detects that there was a
+    service ownership change relating to the \a serviceName service. The \a
+    oldOwner parameter contains the old owner name and \a newOwner is the new
+    owner. Both \a oldOwner and \a newOwner are unique connection names.
+
+    Note that this signal is also emitted whenever the \a serviceName service
+    was registered or unregistered. If it was registered, \a oldOwner will
+    contain an empty string, whereas if it was unregistered, \a newOwner will
+    contain an empty string.
+
+    If you need only to find out if the service is registered or unregistered
+    only, without being notified that the ownership changed, consider using
+    the specific modes for those operations. This class is more efficient if
+    you use the more specific modes.
+
+    \sa serviceRegistered(), serviceUnregistered()
+*/
+
+/*!
+    Creates a QDBusServiceWatcher object. Note that until you set a
+    connection with setConnection(), this object will not emit any signals.
+
+    The \a parent parameter is passed to QObject to set the parent of this
+    object.
+*/
+QDBusServiceWatcher::QDBusServiceWatcher(QObject *parent)
+    : QObject(*new QDBusServiceWatcherPrivate(QDBusConnection(QString()), WatchForOwnerChange), parent)
+{
+}
+
+/*!
+    Creates a QDBusServiceWatcher object and attaches it to the \a connection
+    connection. Also, this function immediately starts watching for \a
+    watchMode changes to service \a service.
+
+    The \a parent parameter is passed to QObject to set the parent of this
+    object.
+*/
+QDBusServiceWatcher::QDBusServiceWatcher(const QString &service, const QDBusConnection &connection, WatchMode watchMode, QObject *parent)
+    : QObject(*new QDBusServiceWatcherPrivate(connection, watchMode), parent)
+{
+    d_func()->setConnection(QStringList() << service, connection, watchMode);
+}
+
+/*!
+    Destroys the QDBusServiceWatcher object and releases any resources
+    associated with it.
+*/
+QDBusServiceWatcher::~QDBusServiceWatcher()
+{
+}
+
+/*!
+    Returns the list of D-Bus services that are being watched.
+
+    \sa setWatchedServices()
+*/
+QStringList QDBusServiceWatcher::watchedServices() const
+{
+    return d_func()->servicesWatched;
+}
+
+/*!
+    Sets the list of D-Bus services being watched to be \a services.
+
+    Note that setting the entire list means removing all previous rules for
+    watching services and adding new ones. This is an expensive operation and
+    should be avoided, if possible. Instead, use addWatchedService() and
+    removeWatchedService() if you can to manipulate entries in the list.
+*/
+void QDBusServiceWatcher::setWatchedServices(const QStringList &services)
+{
+    Q_D(QDBusServiceWatcher);
+    if (services == d->servicesWatched)
+        return;
+    d->setConnection(services, d->connection, d->watchMode);
+}
+
+/*!
+    Adds \a newService to the list of services to be watched by this object.
+    This function is more efficient than setWatchedServices() and should be
+    used whenever possible to add services.
+*/
+void QDBusServiceWatcher::addWatchedService(const QString &newService)
+{
+    Q_D(QDBusServiceWatcher);
+    if (d->servicesWatched.contains(newService))
+        return;
+    d->addService(newService);
+    d->servicesWatched << newService;
+}
+
+/*!
+    Removes the \a service from the list of services being watched by this
+    object. Note that D-Bus notifications are asynchronous, so there may
+    still be signals pending delivery about \a service. Those signals will
+    still be emitted whenever the D-Bus messages are processed.
+
+    This function returns true if any services were removed.
+*/
+bool QDBusServiceWatcher::removeWatchedService(const QString &service)
+{
+    Q_D(QDBusServiceWatcher);
+    d->removeService(service);
+    return d->servicesWatched.removeOne(service);
+}
+
+QDBusServiceWatcher::WatchMode QDBusServiceWatcher::watchMode() const
+{
+    return d_func()->watchMode;
+}
+
+void QDBusServiceWatcher::setWatchMode(WatchMode mode)
+{
+    Q_D(QDBusServiceWatcher);
+    if (mode == d->watchMode)
+        return;
+    d->setConnection(d->servicesWatched, d->connection, mode);
+}
+
+/*!
+    Returns the QDBusConnection that this object is attached to.
+
+    \sa setConnection()
+*/
+QDBusConnection QDBusServiceWatcher::connection() const
+{
+    return d_func()->connection;
+}
+
+/*!
+    Sets the D-Bus connection that this object is attached to be \a
+    connection. All services watched will be transferred to this connection.
+
+    Note that QDBusConnection objects are reference counted:
+    QDBusServiceWatcher will keep a reference for this connection while it
+    exists. The connection is not closed until the reference count drops to
+    zero, so this will ensure that any notifications are received while this
+    QDBusServiceWatcher object exists.
+
+    \sa connection()
+*/
+void QDBusServiceWatcher::setConnection(const QDBusConnection &connection)
+{
+    Q_D(QDBusServiceWatcher);
+    if (connection.name() == d->connection.name())
+        return;
+    d->setConnection(d->servicesWatched, connection, d->watchMode);
+}
+
+#include "moc_qdbusservicewatcher.cpp"
diff --git a/src/dbus/qdbusservicewatcher.h b/src/dbus/qdbusservicewatcher.h
new file mode 100644
index 0000000..a968a9c
--- /dev/null
+++ b/src/dbus/qdbusservicewatcher.h
@@ -0,0 +1,103 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtDBus module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QDBUSSERVICEWATCHER_H
+#define QDBUSSERVICEWATCHER_H
+
+#include <QtCore/qobject.h>
+#include <QtDBus/qdbusmacros.h>
+
+QT_BEGIN_HEADER
+
+QT_BEGIN_NAMESPACE
+
+QT_MODULE(DBus)
+
+class QDBusConnection;
+
+class QDBusServiceWatcherPrivate;
+class QDBUS_EXPORT QDBusServiceWatcher: public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QStringList watchedServices READ watchedServices WRITE setWatchedServices)
+    Q_PROPERTY(WatchMode watchMode READ watchMode WRITE setWatchMode)
+public:
+    enum WatchModeFlag {
+        WatchForRegistration = 0x01,
+        WatchForUnregistration = 0x02,
+        WatchForOwnerChange = 0x03
+    };
+    Q_DECLARE_FLAGS(WatchMode, WatchModeFlag)
+
+    explicit QDBusServiceWatcher(QObject *parent = 0);
+    QDBusServiceWatcher(const QString &service, const QDBusConnection &connection,
+                        WatchMode watchMode = WatchForOwnerChange, QObject *parent = 0);
+    ~QDBusServiceWatcher();
+
+    QStringList watchedServices() const;
+    void setWatchedServices(const QStringList &services);
+    void addWatchedService(const QString &newService);
+    bool removeWatchedService(const QString &service);
+
+    WatchMode watchMode() const;
+    void setWatchMode(WatchMode mode);
+
+    QDBusConnection connection() const;
+    void setConnection(const QDBusConnection &connection);
+
+Q_SIGNALS:
+    void serviceRegistered(const QString &service);
+    void serviceUnregistered(const QString &service);
+    void serviceOwnerChanged(const QString &service, const QString &oldOwner, const QString &newOwner);
+
+private:
+    Q_PRIVATE_SLOT(d_func(), void _q_serviceOwnerChanged(QString,QString,QString))
+    Q_DISABLE_COPY(QDBusServiceWatcher)
+    Q_DECLARE_PRIVATE(QDBusServiceWatcher)
+};
+
+Q_DECLARE_OPERATORS_FOR_FLAGS(QDBusServiceWatcher::WatchMode)
+
+QT_END_NAMESPACE
+
+QT_END_HEADER
+
+#endif // QDBUSSERVICEWATCHER_H
diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
index 9fb0b47..89a6e91 100644
--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
@@ -462,6 +462,7 @@ QAbstractSocketPrivate::QAbstractSocketPrivate()
       isBuffered(false),
       blockingTimeout(30000),
       connectTimer(0),
+      disconnectTimer(0),
       connectTimeElapsed(0),
       hostLookupId(-1),
       socketType(QAbstractSocket::UnknownSocketType),
@@ -497,9 +498,10 @@ void QAbstractSocketPrivate::resetSocketLayer()
         socketEngine = 0;
         cachedSocketDescriptor = -1;
     }
-    if (connectTimer) {
+    if (connectTimer)
         connectTimer->stop();
-    }
+    if (disconnectTimer)
+        disconnectTimer->stop();
 }
 
 /*! \internal
@@ -669,11 +671,11 @@ bool QAbstractSocketPrivate::canWriteNotification()
 
     if (socketEngine) {
 #if defined (Q_OS_WIN)
-	if (!writeBuffer.isEmpty())
-	    socketEngine->setWriteNotificationEnabled(true);
+        if (!writeBuffer.isEmpty())
+            socketEngine->setWriteNotificationEnabled(true);
 #else
-	if (writeBuffer.isEmpty())
-	    socketEngine->setWriteNotificationEnabled(false);
+        if (writeBuffer.isEmpty() && socketEngine->bytesToWrite() == 0)
+            socketEngine->setWriteNotificationEnabled(false);
 #endif
     }
 
@@ -710,11 +712,17 @@ void QAbstractSocketPrivate::connectionNotification()
 bool QAbstractSocketPrivate::flush()
 {
     Q_Q(QAbstractSocket);
-    if (!socketEngine || !socketEngine->isValid() || writeBuffer.isEmpty()) {
+    if (!socketEngine || !socketEngine->isValid() || (writeBuffer.isEmpty()
+        && socketEngine->bytesToWrite() == 0)) {
 #if defined (QABSTRACTSOCKET_DEBUG)
     qDebug("QAbstractSocketPrivate::flush() nothing to do: valid ? %s, writeBuffer.isEmpty() ? %s",
            socketEngine->isValid() ? "yes" : "no", writeBuffer.isEmpty() ? "yes" : "no");
 #endif
+
+        // this covers the case when the buffer was empty, but we had to wait for the socket engine to finish
+        if (state == QAbstractSocket::ClosingState)
+            q->disconnectFromHost();
+
         return false;
     }
 
@@ -751,7 +759,8 @@ bool QAbstractSocketPrivate::flush()
         }
     }
 
-    if (writeBuffer.isEmpty() && socketEngine && socketEngine->isWriteNotificationEnabled())
+    if (writeBuffer.isEmpty() && socketEngine && socketEngine->isWriteNotificationEnabled()
+        && !socketEngine->bytesToWrite())
         socketEngine->setWriteNotificationEnabled(false);
     if (state == QAbstractSocket::ClosingState)
         q->disconnectFromHost();
@@ -1087,6 +1096,15 @@ void QAbstractSocketPrivate::_q_abortConnectionAttempt()
     }
 }
 
+void QAbstractSocketPrivate::_q_forceDisconnect()
+{
+    Q_Q(QAbstractSocket);
+    if (socketEngine && socketEngine->isValid() && state == QAbstractSocket::ClosingState) {
+        socketEngine->close();
+        q->disconnectFromHost();
+    }
+}
+
 /*! \internal
 
     Reads data from the socket layer into the read buffer. Returns
@@ -2347,7 +2365,22 @@ void QAbstractSocket::disconnectFromHostImplementation()
         }
 
         // Wait for pending data to be written.
-        if (d->socketEngine && d->socketEngine->isValid() && d->writeBuffer.size() > 0) {
+        if (d->socketEngine && d->socketEngine->isValid() && (d->writeBuffer.size() > 0
+            || d->socketEngine->bytesToWrite() > 0)) {
+            // hack: when we are waiting for the socket engine to write bytes (only
+            // possible when using Socks5 or HTTP socket engine), then close
+            // anyway after 2 seconds. This is to prevent a timeout on Mac, where we
+            // sometimes just did not get the write notifier from the underlying
+            // CFSocket and no progress was made.
+            if (d->writeBuffer.size() == 0 && d->socketEngine->bytesToWrite() > 0) {
+                if (!d->disconnectTimer) {
+                    d->disconnectTimer = new QTimer(this);
+                    connect(d->disconnectTimer, SIGNAL(timeout()), this,
+                            SLOT(_q_forceDisconnect()), Qt::DirectConnection);
+                }
+                if (!d->disconnectTimer->isActive())
+                    d->disconnectTimer->start(2000);
+            }
             d->socketEngine->setWriteNotificationEnabled(true);
 
 #if defined(QABSTRACTSOCKET_DEBUG)
diff --git a/src/network/socket/qabstractsocket.h b/src/network/socket/qabstractsocket.h
index 5d94a01..5cfae17 100644
--- a/src/network/socket/qabstractsocket.h
+++ b/src/network/socket/qabstractsocket.h
@@ -216,6 +216,7 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_startConnecting(const QHostInfo &))
     Q_PRIVATE_SLOT(d_func(), void _q_abortConnectionAttempt())
     Q_PRIVATE_SLOT(d_func(), void _q_testConnection())
+    Q_PRIVATE_SLOT(d_func(), void _q_forceDisconnect())
 
 #ifdef QT3_SUPPORT
 public:
diff --git a/src/network/socket/qabstractsocket_p.h b/src/network/socket/qabstractsocket_p.h
index 8ccddd3..acf82bf 100644
--- a/src/network/socket/qabstractsocket_p.h
+++ b/src/network/socket/qabstractsocket_p.h
@@ -93,6 +93,7 @@ public:
     void _q_startConnecting(const QHostInfo &hostInfo);
     void _q_testConnection();
     void _q_abortConnectionAttempt();
+    void _q_forceDisconnect();
 
     bool readSocketNotifierCalled;
     bool readSocketNotifierState;
@@ -148,6 +149,7 @@ public:
     int blockingTimeout;
 
     QTimer *connectTimer;
+    QTimer *disconnectTimer;
     int connectTimeElapsed;
 
     int hostLookupId;
diff --git a/src/network/socket/qabstractsocketengine_p.h b/src/network/socket/qabstractsocketengine_p.h
index c639092..14b3c81 100644
--- a/src/network/socket/qabstractsocketengine_p.h
+++ b/src/network/socket/qabstractsocketengine_p.h
@@ -126,6 +126,8 @@ public:
     virtual qint64 pendingDatagramSize() const = 0;
 #endif
 
+    virtual qint64 bytesToWrite() const = 0;
+
     virtual int option(SocketOption option) const = 0;
     virtual bool setOption(SocketOption option, int value) = 0;
 
diff --git a/src/network/socket/qhttpsocketengine.cpp b/src/network/socket/qhttpsocketengine.cpp
index fb61dbf..5c28318 100644
--- a/src/network/socket/qhttpsocketengine.cpp
+++ b/src/network/socket/qhttpsocketengine.cpp
@@ -276,6 +276,16 @@ qint64 QHttpSocketEngine::pendingDatagramSize() const
 }
 #endif // QT_NO_UDPSOCKET
 
+qint64 QHttpSocketEngine::bytesToWrite() const
+{
+    Q_D(const QHttpSocketEngine);
+    if (d->socket) {
+        return d->socket->bytesToWrite();
+    } else {
+        return 0;
+    }
+}
+
 int QHttpSocketEngine::option(SocketOption option) const
 {
     Q_D(const QHttpSocketEngine);
diff --git a/src/network/socket/qhttpsocketengine_p.h b/src/network/socket/qhttpsocketengine_p.h
index a423116..76430db 100644
--- a/src/network/socket/qhttpsocketengine_p.h
+++ b/src/network/socket/qhttpsocketengine_p.h
@@ -110,6 +110,8 @@ public:
     qint64 pendingDatagramSize() const;
 #endif // QT_NO_UDPSOCKET
 
+    qint64 bytesToWrite() const;
+
     int option(SocketOption option) const;
     bool setOption(SocketOption option, int value);
 
diff --git a/src/network/socket/qlocalserver_unix.cpp b/src/network/socket/qlocalserver_unix.cpp
index 5ffe0c0..e09e547 100644
--- a/src/network/socket/qlocalserver_unix.cpp
+++ b/src/network/socket/qlocalserver_unix.cpp
@@ -216,24 +216,14 @@ void QLocalServerPrivate::waitForNewConnection(int msec, bool *timedOut)
     timeout.tv_sec = msec / 1000;
     timeout.tv_usec = (msec % 1000) * 1000;
 
-    // timeout can not be 0 or else select will return an error.
-    if (0 == msec)
-        timeout.tv_usec = 1000;
-
     int result = -1;
-    // on Linux timeout will be updated by select, but _not_ on other systems.
-    QTime timer;
-    timer.start();
-    while (pendingConnections.isEmpty() && (-1 == msec || timer.elapsed() < msec)) {
-        result = ::select(listenSocket + 1, &readfds, 0, 0, &timeout);
-        if (-1 == result && errno != EINTR) {
-            setError(QLatin1String("QLocalServer::waitForNewConnection"));
-            closeServer();
-            break;
-        }
-        if (result > 0)
-            _q_onNewConnection();
+    result = qt_safe_select(listenSocket + 1, &readfds, 0, 0, (msec == -1) ? 0 : &timeout);
+    if (-1 == result) {
+        setError(QLatin1String("QLocalServer::waitForNewConnection"));
+        closeServer();
     }
+    if (result > 0)
+        _q_onNewConnection();
     if (timedOut)
         *timedOut = (result == 0);
 }
diff --git a/src/network/socket/qnativesocketengine.cpp b/src/network/socket/qnativesocketengine.cpp
index 8de821b..ecf5ad9 100644
--- a/src/network/socket/qnativesocketengine.cpp
+++ b/src/network/socket/qnativesocketengine.cpp
@@ -754,6 +754,12 @@ qint64 QNativeSocketEngine::write(const char *data, qint64 size)
     return d->nativeWrite(data, size);
 }
 
+
+qint64 QNativeSocketEngine::bytesToWrite() const
+{
+    return 0;
+}
+
 /*!
     Reads up to \a maxSize bytes into \a data from the socket.
     Returns the number of bytes read, or -1 if an error occurred.
diff --git a/src/network/socket/qnativesocketengine_p.h b/src/network/socket/qnativesocketengine_p.h
index 1f6a243..a03d8f1 100644
--- a/src/network/socket/qnativesocketengine_p.h
+++ b/src/network/socket/qnativesocketengine_p.h
@@ -135,6 +135,8 @@ public:
     bool hasPendingDatagrams() const;
     qint64 pendingDatagramSize() const;
 
+    qint64 bytesToWrite() const;
+
     qint64 receiveBufferSize() const;
     void setReceiveBufferSize(qint64 bufferSize);
 
diff --git a/src/network/socket/qsocks5socketengine.cpp b/src/network/socket/qsocks5socketengine.cpp
index 30074cf..bd60ad1 100644
--- a/src/network/socket/qsocks5socketengine.cpp
+++ b/src/network/socket/qsocks5socketengine.cpp
@@ -1235,6 +1235,9 @@ void QSocks5SocketEnginePrivate::_q_controlSocketError(QAbstractSocket::SocketEr
         if (!readNotificationPending)
             connectData->readBuffer.clear();
         emitReadNotification();
+        data->controlSocket->close();
+        // cause a disconnect in the outer socket
+        emitWriteNotification();
     } else if (socks5State == Uninitialized
                || socks5State == AuthenticationMethodsSent
                || socks5State == Authenticating
@@ -1245,6 +1248,7 @@ void QSocks5SocketEnginePrivate::_q_controlSocketError(QAbstractSocket::SocketEr
     } else {
         q_func()->setError(data->controlSocket->error(), data->controlSocket->errorString());
         emitReadNotification();
+        emitWriteNotification();
     }
 }
 
@@ -1623,6 +1627,16 @@ qint64 QSocks5SocketEngine::pendingDatagramSize() const
 }
 #endif // QT_NO_UDPSOCKET
 
+qint64 QSocks5SocketEngine::bytesToWrite() const
+{
+    Q_D(const QSocks5SocketEngine);
+    if (d->data && d->data->controlSocket) {
+        return d->data->controlSocket->bytesToWrite();
+    } else {
+        return 0;
+    }
+}
+
 int QSocks5SocketEngine::option(SocketOption option) const
 {
     Q_D(const QSocks5SocketEngine);
diff --git a/src/network/socket/qsocks5socketengine_p.h b/src/network/socket/qsocks5socketengine_p.h
index 7cb0920..2402517 100644
--- a/src/network/socket/qsocks5socketengine_p.h
+++ b/src/network/socket/qsocks5socketengine_p.h
@@ -100,6 +100,8 @@ public:
     qint64 pendingDatagramSize() const;
 #endif // QT_NO_UDPSOCKET
 
+    qint64 bytesToWrite() const;
+
     int option(SocketOption option) const;
     bool setOption(SocketOption option, int value);
 
diff --git a/src/network/ssl/qsslsocket.cpp b/src/network/ssl/qsslsocket.cpp
index 1f93534..cfa99c8 100644
--- a/src/network/ssl/qsslsocket.cpp
+++ b/src/network/ssl/qsslsocket.cpp
@@ -713,6 +713,8 @@ void QSslSocket::close()
     qDebug() << "QSslSocket::close()";
 #endif
     Q_D(QSslSocket);
+    if (d->plainSocket)
+        d->plainSocket->close();
     QTcpSocket::close();
 
     // must be cleared, reading/writing not possible on closed socket: