Changeset 43364 in vbox for trunk/src/VBox/Additions

Timestamp:

Sep 20, 2012 12:12:09 PM (13 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

80828

Message:

Haiku Additions: cleanup.

Location:

trunk/src/VBox/Additions/haiku

Files:

• SharedFolders/OpenHashTable.h (modified) (1 diff)
• SharedFolders/vboxsf.c (modified) (1 diff)
• SharedFolders/vboxsf.h (modified) (2 diffs)
• SharedFolders/vnode_cache.cpp (modified) (2 diffs)
• VBoxMouse/VBoxMouse.cpp (modified) (6 diffs)
• VBoxMouse/VBoxMouse.h (modified) (2 diffs)
• VBoxMouse/VBoxMouseFilter.cpp (modified) (2 diffs)
• VBoxTray/VBoxClipboard.cpp (modified) (6 diffs)
• VBoxTray/VBoxClipboard.h (modified) (1 diff)
• VBoxTray/VBoxDisplay.cpp (modified) (3 diffs)
• VBoxTray/VBoxDisplay.h (modified) (1 diff)
• VBoxTray/VBoxGuestApplication.cpp (modified) (3 diffs)
• VBoxTray/VBoxGuestDeskbarView.cpp (modified) (1 diff)
• VBoxTray/VBoxGuestDeskbarView.h (modified) (1 diff)
• VBoxVideo/accelerant/accelerant.cpp (modified) (1 diff)
• VBoxVideo/accelerant/accelerant.h (modified) (2 diffs)
• VBoxVideo/common/VBoxVideo_common.h (modified) (1 diff)
• VBoxVideo/driver/driver.cpp (modified) (2 diffs)

trunk/src/VBox/Additions/haiku/SharedFolders/OpenHashTable.h

@@ -34 +34 @@
 
 #ifdef _KERNEL_MODE
-#       include <KernelExport.h>
-#       include "kernel_cpp.h"
+#    include <KernelExport.h>
+#    include "kernel_cpp.h"
 #endif
 
 /*!
-        The Definition template must have four methods: `HashKey', `Hash',
-        `Compare' and `GetLink;. It must also define several types as shown in the
-        following example:
-
-        struct Foo {
-                int bar;
-
-                Foo* fNext;
-        };
-
-        struct HashTableDefinition {
-                typedef int             KeyType;
-                typedef Foo             ValueType;
-
-                size_t HashKey(int key) const
+    The Definition template must have four methods: `HashKey', `Hash',
+    `Compare' and `GetLink;. It must also define several types as shown in the
+    following example:
+
+    struct Foo {
+        int bar;
+
+        Foo* fNext;
+    };
+
+    struct HashTableDefinition {
+        typedef int        KeyType;
+        typedef    Foo        ValueType;
+
+        size_t HashKey(int key) const
+        {
+            return key >> 1;
+        }
+
+        size_t Hash(Foo* value) const
+        {
+            return HashKey(value->bar);
+        }
+
+        bool Compare(int key, Foo* value) const
+        {
+            return value->bar == key;
+        }
+
+        Foo*& GetLink(Foo* value) const
+        {
+            return value->fNext;
+        }
+    };
+*/
+
+
+struct MallocAllocator
+{
+    void* Allocate(size_t size) const
+    {
+        return malloc(size);
+    }
+
+    void Free(void* memory) const
+    {
+        free(memory);
+    }
+};
+
+
+template<typename Definition, bool AutoExpand = true,
+    bool CheckDuplicates = false, typename Allocator = MallocAllocator>
+class BOpenHashTable
+{
+public:
+    typedef BOpenHashTable<Definition, AutoExpand, CheckDuplicates> HashTable;
+    typedef typename Definition::KeyType      KeyType;
+    typedef typename Definition::ValueType    ValueType;
+
+    static const size_t kMinimumSize = 8;
+
+    // All allocations are of power of 2 lengths.
+
+    // regrowth factor: 200 / 256 = 78.125%
+    //                   50 / 256 = 19.53125%
+
+    BOpenHashTable()
+        :
+        fTableSize(0),
+        fItemCount(0),
+        fTable(NULL)
+    {
+    }
+
+    BOpenHashTable(const Definition& definition)
+        :
+        fDefinition(definition),
+        fTableSize(0),
+        fItemCount(0),
+        fTable(NULL)
+    {
+    }
+
+    BOpenHashTable(const Definition& definition, const Allocator& allocator)
+        :
+        fDefinition(definition),
+        fAllocator(allocator),
+        fTableSize(0),
+        fItemCount(0),
+        fTable(NULL)
+    {
+    }
+
+    ~BOpenHashTable()
+    {
+        fAllocator.Free(fTable);
+    }
+
+    status_t Init(size_t initialSize = kMinimumSize)
+    {
+        if (initialSize > 0 && !_Resize(initialSize))
+            return B_NO_MEMORY;
+        return B_OK;
+    }
+
+    size_t TableSize() const
+    {
+        return fTableSize;
+    }
+
+    size_t CountElements() const
+    {
+        return fItemCount;
+    }
+
+    ValueType* Lookup(const KeyType& key) const
+    {
+        if (fTableSize == 0)
+            return NULL;
+
+        size_t index = fDefinition.HashKey(key) & (fTableSize - 1);
+        ValueType* slot = fTable[index];
+
+        while (slot)
+        {
+            if (fDefinition.Compare(key, slot))
+                break;
+            slot = _Link(slot);
+        }
+
+        return slot;
+    }
+
+    status_t Insert(ValueType* value)
+    {
+        if (fTableSize == 0)
+        {
+            if (!_Resize(kMinimumSize))
+                return B_NO_MEMORY;
+        }
+        else if (AutoExpand && fItemCount >= (fTableSize * 200 / 256))
+            _Resize(fTableSize * 2);
+
+        InsertUnchecked(value);
+        return B_OK;
+    }
+
+    void InsertUnchecked(ValueType* value)
+    {
+        if (CheckDuplicates && _ExhaustiveSearch(value))
+        {
+#ifdef _KERNEL_MODE
+            panic("Hash Table: value already in table.");
+#else
+            debugger("Hash Table: value already in table.");
+#endif
+        }
+
+        _Insert(fTable, fTableSize, value);
+        fItemCount++;
+    }
+
+    // TODO: a ValueType* Remove(const KeyType& key) method is missing
+
+    bool Remove(ValueType* value)
+    {
+        if (!RemoveUnchecked(value))
+            return false;
+
+        if (AutoExpand && fTableSize > kMinimumSize
+            && fItemCount < (fTableSize * 50 / 256))
+            _Resize(fTableSize / 2);
+
+        return true;
+    }
+
+    bool RemoveUnchecked(ValueType* value)
+    {
+        size_t index = fDefinition.Hash(value) & (fTableSize - 1);
+        ValueType* previous = NULL;
+        ValueType* slot = fTable[index];
+
+        while (slot)
+        {
+            ValueType* next = _Link(slot);
+
+            if (value == slot)
+            {
+                if (previous)
+                    _Link(previous) = next;
+                else
+                    fTable[index] = next;
+                break;
+            }
+
+            previous = slot;
+            slot = next;
+        }
+
+        if (slot == NULL)
+            return false;
+
+        if (CheckDuplicates && _ExhaustiveSearch(value))
+        {
+#ifdef _KERNEL_MODE
+            panic("Hash Table: duplicate detected.");
+#else
+            debugger("Hash Table: duplicate detected.");
+#endif
+        }
+
+        fItemCount--;
+        return true;
+    }
+
+    /*!    Removes all elements from the hash table. No resizing happens. The
+        elements are not deleted. If \a returnElements is \c true, the method
+        returns all elements chained via their hash table link.
+    */
+    ValueType* Clear(bool returnElements = false)
+    {
+        if (this->fItemCount == 0)
+            return NULL;
+
+        ValueType* result = NULL;
+
+        if (returnElements)
                 {
-                        return key >> 1;
-                }
-
-                size_t Hash(Foo* value) const
-                {
-                        return HashKey(value->bar);
-                }
-
-                bool Compare(int key, Foo* value) const
-                {
-                        return value->bar == key;
-                }
-
-                Foo*& GetLink(Foo* value) const
-                {
-                        return value->fNext;
-                }
-        };
-*/
-
-
-struct MallocAllocator {
-        void* Allocate(size_t size) const
+            ValueType** nextPointer = &result;
+
+            // iterate through all buckets
+            for (size_t i = 0; i < fTableSize; i++)
+            {
+                ValueType* element = fTable[i];
+                if (element != NULL)
+                {
+                    // add the bucket to the list
+                    *nextPointer = element;
+
+                    // update nextPointer to point to the fNext of the last
+                    // element in the bucket
+                    while (element != NULL)
+                    {
+                        nextPointer = &_Link(element);
+                        element = *nextPointer;
+                    }
+                }
+            }
+        }
+
+        memset(this->fTable, 0, sizeof(ValueType*) * this->fTableSize);
+
+        return result;
+    }
+
+    /*!    If the table needs resizing, the number of bytes for the required
+        allocation is returned. If no resizing is needed, 0 is returned.
+    */
+    size_t ResizeNeeded() const
+    {
+        size_t size = fTableSize;
+        if (size == 0 || fItemCount >= (size * 200 / 256))
+        {
+            // grow table
+            if (size == 0)
+                size = kMinimumSize;
+            while (fItemCount >= size * 200 / 256)
+                size <<= 1;
+        }
+        else if (size > kMinimumSize && fItemCount < size * 50 / 256)
+        {
+            // shrink table
+            while (fItemCount < size * 50 / 256)
+                size >>= 1;
+            if (size < kMinimumSize)
+                size = kMinimumSize;
+        }
+
+        if (size == fTableSize)
+            return 0;
+
+        return size * sizeof(ValueType*);
+    }
+
+    /*!    Resizes the table using the given allocation. The allocation must not
+        be \c NULL. It must be of size \a size, which must a value returned
+        earlier by ResizeNeeded(). If the size requirements have changed in the
+        meantime, the method free()s the given allocation and returns \c false,
+        unless \a force is \c true, in which case the supplied allocation is
+        used in any event.
+        Otherwise \c true is returned.
+        If \a oldTable is non-null and resizing is successful, the old table
+        will not be freed, but will be returned via this parameter instead.
+    */
+    bool Resize(void* allocation, size_t size, bool force = false,
+        void** oldTable = NULL)
+    {
+        if (!force && size != ResizeNeeded())
+        {
+            fAllocator.Free(allocation);
+            return false;
+        }
+
+        _Resize((ValueType**)allocation, size / sizeof(ValueType*), oldTable);
+        return true;
+    }
+
+    class Iterator
         {
-                return malloc(size);
-        }
-
-        void Free(void* memory) const
-        {
-                free(memory);
-        }
+    public:
+        Iterator(const HashTable* table)
+            : fTable(table)
+        {
+            Rewind();
+        }
+
+        Iterator(const HashTable* table, size_t index, ValueType* value)
+            : fTable(table), fIndex(index), fNext(value) {}
+
+        bool HasNext() const { return fNext != NULL; }
+
+        ValueType* Next()
+        {
+            ValueType* current = fNext;
+            _GetNext();
+            return current;
+        }
+
+        void Rewind()
+        {
+            // get the first one
+            fIndex = 0;
+            fNext = NULL;
+            _GetNext();
+        }
+
+    protected:
+        Iterator() {}
+
+        void _GetNext()
+        {
+            if (fNext)
+                fNext = fTable->_Link(fNext);
+
+            while (fNext == NULL && fIndex < fTable->fTableSize)
+                fNext = fTable->fTable[fIndex++];
+        }
+
+        const HashTable* fTable;
+        size_t fIndex;
+        ValueType* fNext;
+    };
+
+    Iterator GetIterator() const
+    {
+        return Iterator(this);
+    }
+
+    Iterator GetIterator(const KeyType& key) const
+    {
+        if (fTableSize == 0)
+            return Iterator(this, fTableSize, NULL);
+
+        size_t index = fDefinition.HashKey(key) & (fTableSize - 1);
+        ValueType* slot = fTable[index];
+
+        while (slot)
+        {
+            if (fDefinition.Compare(key, slot))
+                break;
+            slot = _Link(slot);
+        }
+
+        if (slot == NULL)
+            return Iterator(this, fTableSize, NULL);
+
+        return Iterator(this, index + 1, slot);
+    }
+
+protected:
+    // for g++ 2.95
+    friend class Iterator;
+
+    void _Insert(ValueType** table, size_t tableSize, ValueType* value)
+    {
+        size_t index = fDefinition.Hash(value) & (tableSize - 1);
+
+        _Link(value) = table[index];
+        table[index] = value;
+    }
+
+    bool _Resize(size_t newSize)
+    {
+        ValueType** newTable
+            = (ValueType**)fAllocator.Allocate(sizeof(ValueType*) * newSize);
+        if (newTable == NULL)
+            return false;
+
+        _Resize(newTable, newSize);
+        return true;
+    }
+
+    void _Resize(ValueType** newTable, size_t newSize, void** _oldTable = NULL)
+    {
+        for (size_t i = 0; i < newSize; i++)
+            newTable[i] = NULL;
+
+        if (fTable)
+        {
+            for (size_t i = 0; i < fTableSize; i++)
+            {
+                ValueType* bucket = fTable[i];
+                while (bucket)
+                {
+                    ValueType* next = _Link(bucket);
+                    _Insert(newTable, newSize, bucket);
+                    bucket = next;
+                }
+            }
+
+            if (_oldTable != NULL)
+                *_oldTable = fTable;
+            else
+                fAllocator.Free(fTable);
+        }
+        else if (_oldTable != NULL)
+            *_oldTable = NULL;
+
+        fTableSize = newSize;
+        fTable = newTable;
+    }
+
+    ValueType*& _Link(ValueType* bucket) const
+    {
+        return fDefinition.GetLink(bucket);
+    }
+
+    bool _ExhaustiveSearch(ValueType* value) const
+    {
+        for (size_t i = 0; i < fTableSize; i++)
+        {
+            ValueType* bucket = fTable[i];
+            while (bucket) {
+                if (bucket == value)
+                    return true;
+                bucket = _Link(bucket);
+            }
+        }
+
+        return false;
+    }
+
+    Definition        fDefinition;
+    Allocator        fAllocator;
+    size_t            fTableSize;
+    size_t            fItemCount;
+    ValueType**        fTable;
 };
 
-
-template<typename Definition, bool AutoExpand = true,
-        bool CheckDuplicates = false, typename Allocator = MallocAllocator>
-class BOpenHashTable {
-public:
-        typedef BOpenHashTable<Definition, AutoExpand, CheckDuplicates> HashTable;
-        typedef typename Definition::KeyType    KeyType;
-        typedef typename Definition::ValueType  ValueType;
-
-        static const size_t kMinimumSize = 8;
-
-        // All allocations are of power of 2 lengths.
-
-        // regrowth factor: 200 / 256 = 78.125%
-        //                   50 / 256 = 19.53125%
-
-        BOpenHashTable()
-                :
-                fTableSize(0),
-                fItemCount(0),
-                fTable(NULL)
-        {
-        }
-
-        BOpenHashTable(const Definition& definition)
-                :
-                fDefinition(definition),
-                fTableSize(0),
-                fItemCount(0),
-                fTable(NULL)
-        {
-        }
-
-        BOpenHashTable(const Definition& definition, const Allocator& allocator)
-                :
-                fDefinition(definition),
-                fAllocator(allocator),
-                fTableSize(0),
-                fItemCount(0),
-                fTable(NULL)
-        {
-        }
-
-        ~BOpenHashTable()
-        {
-                fAllocator.Free(fTable);
-        }
-
-        status_t Init(size_t initialSize = kMinimumSize)
-        {
-                if (initialSize > 0 && !_Resize(initialSize))
-                        return B_NO_MEMORY;
-                return B_OK;
-        }
-
-        size_t TableSize() const
-        {
-                return fTableSize;
-        }
-
-        size_t CountElements() const
-        {
-                return fItemCount;
-        }
-
-        ValueType* Lookup(const KeyType& key) const
-        {
-                if (fTableSize == 0)
-                        return NULL;
-
-                size_t index = fDefinition.HashKey(key) & (fTableSize - 1);
-                ValueType* slot = fTable[index];
-
-                while (slot) {
-                        if (fDefinition.Compare(key, slot))
-                                break;
-                        slot = _Link(slot);
-                }
-
-                return slot;
-        }
-
-        status_t Insert(ValueType* value)
-        {
-                if (fTableSize == 0) {
-                        if (!_Resize(kMinimumSize))
-                                return B_NO_MEMORY;
-                } else if (AutoExpand && fItemCount >= (fTableSize * 200 / 256))
-                        _Resize(fTableSize * 2);
-
-                InsertUnchecked(value);
-                return B_OK;
-        }
-
-        void InsertUnchecked(ValueType* value)
-        {
-                if (CheckDuplicates && _ExhaustiveSearch(value)) {
-#ifdef _KERNEL_MODE
-                        panic("Hash Table: value already in table.");
-#else
-                        debugger("Hash Table: value already in table.");
-#endif
-                }
-
-                _Insert(fTable, fTableSize, value);
-                fItemCount++;
-        }
-
-        // TODO: a ValueType* Remove(const KeyType& key) method is missing
-
-        bool Remove(ValueType* value)
-        {
-                if (!RemoveUnchecked(value))
-                        return false;
-
-                if (AutoExpand && fTableSize > kMinimumSize
-                        && fItemCount < (fTableSize * 50 / 256))
-                        _Resize(fTableSize / 2);
-
-                return true;
-        }
-
-        bool RemoveUnchecked(ValueType* value)
-        {
-                size_t index = fDefinition.Hash(value) & (fTableSize - 1);
-                ValueType* previous = NULL;
-                ValueType* slot = fTable[index];
-
-                while (slot) {
-                        ValueType* next = _Link(slot);
-
-                        if (value == slot) {
-                                if (previous)
-                                        _Link(previous) = next;
-                                else
-                                        fTable[index] = next;
-                                break;
-                        }
-
-                        previous = slot;
-                        slot = next;
-                }
-
-                if (slot == NULL)
-                        return false;
-
-                if (CheckDuplicates && _ExhaustiveSearch(value)) {
-#ifdef _KERNEL_MODE
-                        panic("Hash Table: duplicate detected.");
-#else
-                        debugger("Hash Table: duplicate detected.");
-#endif
-                }
-
-                fItemCount--;
-                return true;
-        }
-
-        /*!     Removes all elements from the hash table. No resizing happens. The
-                elements are not deleted. If \a returnElements is \c true, the method
-                returns all elements chained via their hash table link.
-        */
-        ValueType* Clear(bool returnElements = false)
-        {
-                if (this->fItemCount == 0)
-                        return NULL;
-
-                ValueType* result = NULL;
-
-                if (returnElements) {
-                        ValueType** nextPointer = &result;
-
-                        // iterate through all buckets
-                        for (size_t i = 0; i < fTableSize; i++) {
-                                ValueType* element = fTable[i];
-                                if (element != NULL) {
-                                        // add the bucket to the list
-                                        *nextPointer = element;
-
-                                        // update nextPointer to point to the fNext of the last
-                                        // element in the bucket
-                                        while (element != NULL) {
-                                                nextPointer = &_Link(element);
-                                                element = *nextPointer;
-                                        }
-                                }
-                        }
-                }
-
-                memset(this->fTable, 0, sizeof(ValueType*) * this->fTableSize);
-
-                return result;
-        }
-
-        /*!     If the table needs resizing, the number of bytes for the required
-                allocation is returned. If no resizing is needed, 0 is returned.
-        */
-        size_t ResizeNeeded() const
-        {
-                size_t size = fTableSize;
-                if (size == 0 || fItemCount >= (size * 200 / 256)) {
-                        // grow table
-                        if (size == 0)
-                                size = kMinimumSize;
-                        while (fItemCount >= size * 200 / 256)
-                                size <<= 1;
-                } else if (size > kMinimumSize && fItemCount < size * 50 / 256) {
-                        // shrink table
-                        while (fItemCount < size * 50 / 256)
-                                size >>= 1;
-                        if (size < kMinimumSize)
-                                size = kMinimumSize;
-                }
-
-                if (size == fTableSize)
-                        return 0;
-
-                return size * sizeof(ValueType*);
-        }
-
-        /*!     Resizes the table using the given allocation. The allocation must not
-                be \c NULL. It must be of size \a size, which must a value returned
-                earlier by ResizeNeeded(). If the size requirements have changed in the
-                meantime, the method free()s the given allocation and returns \c false,
-                unless \a force is \c true, in which case the supplied allocation is
-                used in any event.
-                Otherwise \c true is returned.
-                If \a oldTable is non-null and resizing is successful, the old table
-                will not be freed, but will be returned via this parameter instead.
-        */
-        bool Resize(void* allocation, size_t size, bool force = false,
-                void** oldTable = NULL)
-        {
-                if (!force && size != ResizeNeeded()) {
-                        fAllocator.Free(allocation);
-                        return false;
-                }
-
-                _Resize((ValueType**)allocation, size / sizeof(ValueType*), oldTable);
-                return true;
-        }
-
-        class Iterator {
-        public:
-                Iterator(const HashTable* table)
-                        : fTable(table)
-                {
-                        Rewind();
-                }
-
-                Iterator(const HashTable* table, size_t index, ValueType* value)
-                        : fTable(table), fIndex(index), fNext(value) {}
-
-                bool HasNext() const { return fNext != NULL; }
-
-                ValueType* Next()
-                {
-                        ValueType* current = fNext;
-                        _GetNext();
-                        return current;
-                }
-
-                void Rewind()
-                {
-                        // get the first one
-                        fIndex = 0;
-                        fNext = NULL;
-                        _GetNext();
-                }
-
-        protected:
-                Iterator() {}
-
-                void _GetNext()
-                {
-                        if (fNext)
-                                fNext = fTable->_Link(fNext);
-
-                        while (fNext == NULL && fIndex < fTable->fTableSize)
-                                fNext = fTable->fTable[fIndex++];
-                }
-
-                const HashTable* fTable;
-                size_t fIndex;
-                ValueType* fNext;
-        };
-
-        Iterator GetIterator() const
-        {
-                return Iterator(this);
-        }
-
-        Iterator GetIterator(const KeyType& key) const
-        {
-                if (fTableSize == 0)
-                        return Iterator(this, fTableSize, NULL);
-
-                size_t index = fDefinition.HashKey(key) & (fTableSize - 1);
-                ValueType* slot = fTable[index];
-
-                while (slot) {
-                        if (fDefinition.Compare(key, slot))
-                                break;
-                        slot = _Link(slot);
-                }
-
-                if (slot == NULL)
-                        return Iterator(this, fTableSize, NULL);
-
-                return Iterator(this, index + 1, slot);
-        }
-
-protected:
-        // for g++ 2.95
-        friend class Iterator;
-
-        void _Insert(ValueType** table, size_t tableSize, ValueType* value)
-        {
-                size_t index = fDefinition.Hash(value) & (tableSize - 1);
-
-                _Link(value) = table[index];
-                table[index] = value;
-        }
-
-        bool _Resize(size_t newSize)
-        {
-                ValueType** newTable
-                        = (ValueType**)fAllocator.Allocate(sizeof(ValueType*) * newSize);
-                if (newTable == NULL)
-                        return false;
-
-                _Resize(newTable, newSize);
-                return true;
-        }
-
-        void _Resize(ValueType** newTable, size_t newSize, void** _oldTable = NULL)
-        {
-                for (size_t i = 0; i < newSize; i++)
-                        newTable[i] = NULL;
-
-                if (fTable) {
-                        for (size_t i = 0; i < fTableSize; i++) {
-                                ValueType* bucket = fTable[i];
-                                while (bucket) {
-                                        ValueType* next = _Link(bucket);
-                                        _Insert(newTable, newSize, bucket);
-                                        bucket = next;
-                                }
-                        }
-
-                        if (_oldTable != NULL)
-                                *_oldTable = fTable;
-                        else
-                                fAllocator.Free(fTable);
-                } else if (_oldTable != NULL)
-                        *_oldTable = NULL;
-
-                fTableSize = newSize;
-                fTable = newTable;
-        }
-
-        ValueType*& _Link(ValueType* bucket) const
-        {
-                return fDefinition.GetLink(bucket);
-        }
-
-        bool _ExhaustiveSearch(ValueType* value) const
-        {
-                for (size_t i = 0; i < fTableSize; i++) {
-                        ValueType* bucket = fTable[i];
-                        while (bucket) {
-                                if (bucket == value)
-                                        return true;
-                                bucket = _Link(bucket);
-                        }
-                }
-
-                return false;
-        }
-
-        Definition              fDefinition;
-        Allocator               fAllocator;
-        size_t                  fTableSize;
-        size_t                  fItemCount;
-        ValueType**             fTable;
-};
-
-#endif  // _KERNEL_UTIL_OPEN_HASH_TABLE_H
+#endif    // _KERNEL_UTIL_OPEN_HASH_TABLE_H
+

trunk/src/VBox/Additions/haiku/SharedFolders/vboxsf.c

@@ -55 +55 @@
 status_t init_module(void)
 {
-        if (get_module(VBOXGUEST_MODULE_NAME, (module_info **)&g_VBoxGuest) != B_OK) {
-                dprintf("get_module(%s) failed\n", VBOXGUEST_MODULE_NAME);
-                return B_ERROR;
-        }
-
-        if (RT_FAILURE(vboxInit())) {
-                dprintf("vboxInit failed\n");
-                return B_ERROR;
-        }
-
-        if (RT_FAILURE(vboxConnect(&g_clientHandle))) {
-                dprintf("vboxConnect failed\n");
-                return B_ERROR;
-        }
-
-        if (RT_FAILURE(vboxCallSetUtf8(&g_clientHandle))) {
-                dprintf("vboxCallSetUtf8 failed\n");
-                return B_ERROR;
-        }
-
-        if (RT_FAILURE(vboxCallSetSymlinks(&g_clientHandle))) {
-                dprintf("warning: vboxCallSetSymlinks failed (old vbox?) - symlinks will appear as copies\n");
-        }
-
-        mutex_init(&g_vnodeCacheLock, "vboxsf vnode cache lock");
-
-        dprintf(FS_NAME ": inited successfully\n");
-        return B_OK;
+    if (get_module(VBOXGUEST_MODULE_NAME, (module_info **)&g_VBoxGuest) != B_OK)
+    {
+        dprintf("get_module(%s) failed\n", VBOXGUEST_MODULE_NAME);
+        return B_ERROR;
+    }
+
+    if (RT_FAILURE(vboxInit()))
+    {
+        dprintf("vboxInit failed\n");
+        return B_ERROR;
+    }
+
+    if (RT_FAILURE(vboxConnect(&g_clientHandle)))
+    {
+        dprintf("vboxConnect failed\n");
+        return B_ERROR;
+    }
+
+    if (RT_FAILURE(vboxCallSetUtf8(&g_clientHandle)))
+    {
+        dprintf("vboxCallSetUtf8 failed\n");
+        return B_ERROR;
+    }
+
+    if (RT_FAILURE(vboxCallSetSymlinks(&g_clientHandle)))
+    {
+        dprintf("warning: vboxCallSetSymlinks failed (old vbox?) - symlinks will appear as copies\n");
+    }
+
+    mutex_init(&g_vnodeCacheLock, "vboxsf vnode cache lock");
+
+    dprintf(FS_NAME ": inited successfully\n");
+    return B_OK;
 }
 
 void uninit_module(void)
 {
-        mutex_destroy(&g_vnodeCacheLock);
-        put_module(VBOXGUEST_MODULE_NAME);
-}
-
-PSHFLSTRING make_shflstring(const char* const s) {
-        int len = strlen(s);
-        if (len > 0xFFFE) {
-                dprintf(FS_NAME ": make_shflstring: string too long\n");
-                return NULL;
-        }
-
-        PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + len);
-        if (!rv) {
-                return NULL;
-        }
-
-        rv->u16Length = len;
+    mutex_destroy(&g_vnodeCacheLock);
+    put_module(VBOXGUEST_MODULE_NAME);
+}
+
+
+PSHFLSTRING make_shflstring(const char* const s)
+{
+    int len = strlen(s);
+    if (len > 0xFFFE)
+    {
+        dprintf(FS_NAME ": make_shflstring: string too long\n");
+        return NULL;
+    }
+
+    PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + len);
+    if (!rv)
+        return NULL;
+
+    rv->u16Length = len;
     rv->u16Size = len + 1;
     strcpy(rv->String.utf8, s);
-        return rv;
-}
-
-PSHFLSTRING clone_shflstring(PSHFLSTRING s) {
-        PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s->u16Length);
-        if (rv)
-                memcpy(rv, s, sizeof(SHFLSTRING) + s->u16Length);
-        return rv;
-}
-
-PSHFLSTRING concat_shflstring_cstr(PSHFLSTRING s1, const char* const s2) {
-        size_t s2len = strlen(s2);
-        PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s1->u16Length + s2len);
-        if (rv) {
-                memcpy(rv, s1, sizeof(SHFLSTRING) + s1->u16Length);
-                strcat(rv->String.utf8, s2);
-                rv->u16Length += s2len;
-                rv->u16Size += s2len;
-        }
-        return rv;
-}
-
-PSHFLSTRING concat_cstr_shflstring(const char* const s1, PSHFLSTRING s2) {
-        size_t s1len = strlen(s1);
-        PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s1len + s2->u16Length);
-        if (rv) {
-                strcpy(rv->String.utf8, s1);
-                strcat(rv->String.utf8, s2->String.utf8);
-                rv->u16Length = s1len + s2->u16Length;
-                rv->u16Size = rv->u16Length + 1;
-        }
-        return rv;
-}
-
-PSHFLSTRING build_path(vboxsf_vnode* dir, const char* const name) {
-
-        dprintf("*** build_path(%p, %p)\n", dir, name);
-        if (!dir || !name)
-                return NULL;
-
-        size_t len = dir->path->u16Length + strlen(name) + 1;
-
-        PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + len);
-        if (rv) {
-                strcpy(rv->String.utf8, dir->path->String.utf8);
-                strcat(rv->String.utf8, "/");
-                strcat(rv->String.utf8, name);
-                rv->u16Length = len;
-                rv->u16Size = rv->u16Length + 1;
-        }
-        return rv;
-}
-
-status_t mount(fs_volume *volume, const char *device, uint32 flags, const char *args, ino_t *_rootVnodeID) {
-        if (device) {
-                dprintf(FS_NAME ": trying to mount a real device as a vbox share is silly\n");
-                return B_BAD_TYPE;
-        }
-
-        dprintf(FS_NAME ": mount(%s)\n", args);
-
-        PSHFLSTRING sharename = make_shflstring(args);
-
-        vboxsf_volume* vbsfvolume = malloc(sizeof(vboxsf_volume));
-        volume->private_volume = vbsfvolume;
-        int rv = vboxCallMapFolder(&g_clientHandle, sharename, &(vbsfvolume->map));
-        free(sharename);
-
-        if (rv == 0) {
-                vboxsf_vnode* root_vnode;
-
-                PSHFLSTRING name = make_shflstring("");
-                if (!name) {
-                        dprintf(FS_NAME ": make_shflstring() failed\n");
-                        return B_NO_MEMORY;
-                }
-
-                status_t rs = vboxsf_new_vnode(&vbsfvolume->map, name, name, &root_vnode);
-                dprintf(FS_NAME ": allocated %p (path=%p name=%p)\n", root_vnode, root_vnode->path, root_vnode->name);
-
-                if (rs != B_OK) {
-                        dprintf(FS_NAME ": vboxsf_new_vnode() failed (%d)\n", (int)rs);
-                        return rs;
-                }
-
-                rs = publish_vnode(volume, root_vnode->vnode, root_vnode, &vboxsf_vnode_ops, S_IFDIR, 0);
-                dprintf(FS_NAME ": publish_vnode(): %d\n", (int)rs);
-                *_rootVnodeID = root_vnode->vnode;
-                volume->ops = &vboxsf_volume_ops;
-                return B_OK;
-        }
-        else {
-                dprintf(FS_NAME ": vboxCallMapFolder failed (%d)\n", rv);
-                free(volume->private_volume);
-                return vbox_err_to_haiku_err(rv);
-        }
-}
-
-status_t unmount(fs_volume *volume) {
-        dprintf(FS_NAME ": unmount\n");
-        vboxCallUnmapFolder(&g_clientHandle, volume->private_volume);
-        return B_OK;
-}
-
-status_t vboxsf_read_stat(fs_volume* _volume, fs_vnode* _vnode, struct stat* st) {
-        vboxsf_vnode* vnode = _vnode->private_node;
-        vboxsf_volume* volume = _volume->private_volume;
-        SHFLCREATEPARMS params;
-        int rc;
-
-        dprintf("vboxsf_read_stat (_vnode=%p, vnode=%p, path=%p (%s))\n", _vnode, vnode, vnode->path->String.utf8, vnode->path->String.utf8);
-
-        params.Handle = SHFL_HANDLE_NIL;
-        params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
-        dprintf("sf_stat: calling vboxCallCreate, file %s, flags %x\n", vnode->path->String.utf8, params.CreateFlags);
-        rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
-        if (rc == VERR_INVALID_NAME)
-        {
-                /* this can happen for names like 'foo*' on a Windows host */
-                return B_ENTRY_NOT_FOUND;
-        }
-        if (RT_FAILURE(rc))
-        {
-                dprintf("vboxCallCreate: %d\n", params.Result);
-                return vbox_err_to_haiku_err(params.Result);
-        }
-        if (params.Result != SHFL_FILE_EXISTS)
-        {
-                dprintf("vboxCallCreate: %d\n", params.Result);
-                return B_ENTRY_NOT_FOUND;
-        }
-
-        st->st_dev = 0;
-        st->st_ino = vnode->vnode;
-        st->st_mode = mode_from_fmode(params.Info.Attr.fMode);
-        st->st_nlink = 1;
-        st->st_uid = 0;
-        st->st_gid = 0;
-        st->st_rdev = 0;
-        st->st_size = params.Info.cbObject;
-        st->st_blksize = 1;
-        st->st_blocks = params.Info.cbAllocated;
-        st->st_atime = RTTimeSpecGetSeconds(&params.Info.AccessTime);
-        st->st_mtime = RTTimeSpecGetSeconds(&params.Info.ModificationTime);
-        st->st_ctime = RTTimeSpecGetSeconds(&params.Info.BirthTime);
-        return B_OK;
-}
-
-status_t vboxsf_open_dir(fs_volume* _volume, fs_vnode* _vnode, void** _cookie) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_vnode* vnode = _vnode->private_node;
-        SHFLCREATEPARMS params;
-
-        RT_ZERO(params);
-        params.Handle = SHFL_HANDLE_NIL;
-        params.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS
-                | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
-
-        int rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
-        if (RT_SUCCESS(rc)) {
-                if (params.Result == SHFL_FILE_EXISTS && params.Handle != SHFL_HANDLE_NIL) {
-                        vboxsf_dir_cookie* cookie = malloc(sizeof(vboxsf_dir_cookie));
-                        *_cookie = cookie;
-                        cookie->index = 0;
-                        cookie->path = build_path(vnode, "*");
-                        cookie->handle = params.Handle;
-                        cookie->has_more_files = true;
-                        cookie->buffer_start = cookie->buffer = NULL;
-                        cookie->buffer_length = cookie->num_files = 0;
-                        return B_OK;
-                }
-                else {
-                        return B_ENTRY_NOT_FOUND;
-                }
-        }
-        else {
-                dprintf(FS_NAME ": vboxCallCreate: %d\n", rc);
-                return vbox_err_to_haiku_err(rc);
-        }
-}
+    return rv;
+}
+
+
+PSHFLSTRING clone_shflstring(PSHFLSTRING s)
+{
+    PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s->u16Length);
+    if (rv)
+        memcpy(rv, s, sizeof(SHFLSTRING) + s->u16Length);
+    return rv;
+}
+
+PSHFLSTRING concat_shflstring_cstr(PSHFLSTRING s1, const char* const s2)
+{
+    size_t s2len = strlen(s2);
+    PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s1->u16Length + s2len);
+    if (rv)
+    {
+        memcpy(rv, s1, sizeof(SHFLSTRING) + s1->u16Length);
+        strcat(rv->String.utf8, s2);
+        rv->u16Length += s2len;
+        rv->u16Size += s2len;
+    }
+    return rv;
+}
+
+
+PSHFLSTRING concat_cstr_shflstring(const char* const s1, PSHFLSTRING s2)
+{
+    size_t s1len = strlen(s1);
+    PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + s1len + s2->u16Length);
+    if (rv)
+    {
+        strcpy(rv->String.utf8, s1);
+        strcat(rv->String.utf8, s2->String.utf8);
+        rv->u16Length = s1len + s2->u16Length;
+        rv->u16Size = rv->u16Length + 1;
+    }
+    return rv;
+}
+
+
+PSHFLSTRING build_path(vboxsf_vnode* dir, const char* const name)
+{
+
+    dprintf("*** build_path(%p, %p)\n", dir, name);
+    if (!dir || !name)
+        return NULL;
+
+    size_t len = dir->path->u16Length + strlen(name) + 1;
+    PSHFLSTRING rv = malloc(sizeof(SHFLSTRING) + len);
+    if (rv)
+    {
+        strcpy(rv->String.utf8, dir->path->String.utf8);
+        strcat(rv->String.utf8, "/");
+        strcat(rv->String.utf8, name);
+        rv->u16Length = len;
+        rv->u16Size = rv->u16Length + 1;
+    }
+    return rv;
+}
+
+
+status_t mount(fs_volume *volume, const char *device, uint32 flags, const char *args, ino_t *_rootVnodeID)
+{
+    if (device)
+    {
+        dprintf(FS_NAME ": trying to mount a real device as a vbox share is silly\n");
+        return B_BAD_TYPE;
+    }
+
+    dprintf(FS_NAME ": mount(%s)\n", args);
+
+    PSHFLSTRING sharename = make_shflstring(args);
+
+    vboxsf_volume* vbsfvolume = malloc(sizeof(vboxsf_volume));
+    volume->private_volume = vbsfvolume;
+    int rv = vboxCallMapFolder(&g_clientHandle, sharename, &(vbsfvolume->map));
+    free(sharename);
+
+    if (rv == 0)
+    {
+        vboxsf_vnode* root_vnode;
+
+        PSHFLSTRING name = make_shflstring("");
+        if (!name)
+        {
+            dprintf(FS_NAME ": make_shflstring() failed\n");
+            return B_NO_MEMORY;
+        }
+
+        status_t rs = vboxsf_new_vnode(&vbsfvolume->map, name, name, &root_vnode);
+        dprintf(FS_NAME ": allocated %p (path=%p name=%p)\n", root_vnode, root_vnode->path, root_vnode->name);
+
+        if (rs != B_OK)
+        {
+            dprintf(FS_NAME ": vboxsf_new_vnode() failed (%d)\n", (int)rs);
+            return rs;
+        }
+
+        rs = publish_vnode(volume, root_vnode->vnode, root_vnode, &vboxsf_vnode_ops, S_IFDIR, 0);
+        dprintf(FS_NAME ": publish_vnode(): %d\n", (int)rs);
+        *_rootVnodeID = root_vnode->vnode;
+        volume->ops = &vboxsf_volume_ops;
+        return B_OK;
+    }
+    else
+    {
+        dprintf(FS_NAME ": vboxCallMapFolder failed (%d)\n", rv);
+        free(volume->private_volume);
+        return vbox_err_to_haiku_err(rv);
+    }
+}
+
+
+status_t unmount(fs_volume *volume)
+{
+    dprintf(FS_NAME ": unmount\n");
+    vboxCallUnmapFolder(&g_clientHandle, volume->private_volume);
+    return B_OK;
+}
+
+
+status_t vboxsf_read_stat(fs_volume* _volume, fs_vnode* _vnode, struct stat* st)
+{
+    vboxsf_vnode* vnode = _vnode->private_node;
+    vboxsf_volume* volume = _volume->private_volume;
+    SHFLCREATEPARMS params;
+    int rc;
+
+    dprintf("vboxsf_read_stat (_vnode=%p, vnode=%p, path=%p (%s))\n", _vnode, vnode, vnode->path->String.utf8, vnode->path->String.utf8);
+
+    params.Handle = SHFL_HANDLE_NIL;
+    params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
+    dprintf("sf_stat: calling vboxCallCreate, file %s, flags %x\n", vnode->path->String.utf8, params.CreateFlags);
+    rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
+    if (rc == VERR_INVALID_NAME)
+    {
+        /* this can happen for names like 'foo*' on a Windows host */
+        return B_ENTRY_NOT_FOUND;
+    }
+    if (RT_FAILURE(rc))
+    {
+        dprintf("vboxCallCreate: %d\n", params.Result);
+        return vbox_err_to_haiku_err(params.Result);
+    }
+    if (params.Result != SHFL_FILE_EXISTS)
+    {
+        dprintf("vboxCallCreate: %d\n", params.Result);
+        return B_ENTRY_NOT_FOUND;
+    }
+
+    st->st_dev = 0;
+    st->st_ino = vnode->vnode;
+    st->st_mode = mode_from_fmode(params.Info.Attr.fMode);
+    st->st_nlink = 1;
+    st->st_uid = 0;
+    st->st_gid = 0;
+    st->st_rdev = 0;
+    st->st_size = params.Info.cbObject;
+    st->st_blksize = 1;
+    st->st_blocks = params.Info.cbAllocated;
+    st->st_atime = RTTimeSpecGetSeconds(&params.Info.AccessTime);
+    st->st_mtime = RTTimeSpecGetSeconds(&params.Info.ModificationTime);
+    st->st_ctime = RTTimeSpecGetSeconds(&params.Info.BirthTime);
+    return B_OK;
+}
+
+
+status_t vboxsf_open_dir(fs_volume* _volume, fs_vnode* _vnode, void** _cookie)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_vnode* vnode = _vnode->private_node;
+    SHFLCREATEPARMS params;
+
+    RT_ZERO(params);
+    params.Handle = SHFL_HANDLE_NIL;
+    params.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS
+        | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACCESS_READ;
+
+    int rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
+    if (RT_SUCCESS(rc))
+    {
+        if (params.Result == SHFL_FILE_EXISTS && params.Handle != SHFL_HANDLE_NIL)
+        {
+            vboxsf_dir_cookie* cookie = malloc(sizeof(vboxsf_dir_cookie));
+            *_cookie = cookie;
+            cookie->index = 0;
+            cookie->path = build_path(vnode, "*");
+            cookie->handle = params.Handle;
+            cookie->has_more_files = true;
+            cookie->buffer_start = cookie->buffer = NULL;
+            cookie->buffer_length = cookie->num_files = 0;
+            return B_OK;
+        }
+        else
+            return B_ENTRY_NOT_FOUND;
+    }
+    else
+    {
+        dprintf(FS_NAME ": vboxCallCreate: %d\n", rc);
+        return vbox_err_to_haiku_err(rc);
+    }
+}
+
 
 /** read a single entry from a dir */
 status_t vboxsf_read_dir_1(vboxsf_volume* volume, vboxsf_vnode* vnode, vboxsf_dir_cookie* cookie,
-        struct dirent* buffer, size_t bufferSize) {
-        dprintf("%p, %d, %p\n", cookie, cookie->has_more_files, cookie->buffer);
-        if (!cookie->has_more_files) {
-                return B_ENTRY_NOT_FOUND;
-        }
-        if (!cookie->buffer) {
-                cookie->buffer_length = 16384;
-                cookie->buffer_start = cookie->buffer = malloc(cookie->buffer_length);
-
-                int rc = vboxCallDirInfo(&g_clientHandle, &volume->map, cookie->handle, cookie->path,
-                        0, cookie->index, &cookie->buffer_length, cookie->buffer, &cookie->num_files);
-
-                if (rc != 0 && rc != VERR_NO_MORE_FILES) {
-                        dprintf(FS_NAME ": vboxCallDirInfo failed: %d\n", rc);
-                        free(cookie->buffer_start);
-                        cookie->buffer_start = NULL;
-                        return vbox_err_to_haiku_err(rc);
-                }
-
-                if (rc == VERR_NO_MORE_FILES) {
-                        free(cookie->buffer_start);
-                        cookie->buffer_start = NULL;
-                        cookie->has_more_files = false;
-                        return B_ENTRY_NOT_FOUND;
-                }
-        }
-
-        if (bufferSize <= sizeof(struct dirent) + cookie->buffer->name.u16Length) {
-                dprintf("hit end of buffer\n");
-                return B_BUFFER_OVERFLOW;
-        }
-
-        PSHFLSTRING name1 = clone_shflstring(&cookie->buffer->name);
-        if (!name1) {
-                dprintf(FS_NAME ": make_shflstring() failed\n");
-                return B_NO_MEMORY;
-        }
-
-        vboxsf_vnode* new_vnode;
-        int rv = vboxsf_new_vnode(&volume->map, build_path(vnode, name1->String.utf8), name1, &new_vnode);
-        if (rv != B_OK) {
-                dprintf(FS_NAME ": vboxsf_new_vnode() failed\n");
-                return rv;
-        }
-        buffer->d_dev = 0;
-        buffer->d_pdev = 0;
-        buffer->d_ino = new_vnode->vnode;
-        buffer->d_pino = vnode->vnode;
-        buffer->d_reclen = sizeof(struct dirent) + cookie->buffer->name.u16Length;
-        strncpy(buffer->d_name, cookie->buffer->name.String.utf8, NAME_MAX);
-
-        size_t size = offsetof(SHFLDIRINFO, name.String) + cookie->buffer->name.u16Size;
-        cookie->buffer = ((void*)cookie->buffer + size);
-        cookie->index++;
-
-        if (cookie->index >= cookie->num_files) {
-                // hit end of this buffer, next call will reallocate a new one
-                free(cookie->buffer_start);
-                cookie->buffer_start = cookie->buffer = NULL;
-        }
-        return B_OK;
-}
+    struct dirent* buffer, size_t bufferSize)
+{
+    dprintf("%p, %d, %p\n", cookie, cookie->has_more_files, cookie->buffer);
+    if (!cookie->has_more_files)
+        return B_ENTRY_NOT_FOUND;
+
+    if (!cookie->buffer)
+    {
+        cookie->buffer_length = 16384;
+        cookie->buffer_start = cookie->buffer = malloc(cookie->buffer_length);
+
+        int rc = vboxCallDirInfo(&g_clientHandle, &volume->map, cookie->handle, cookie->path,
+            0, cookie->index, &cookie->buffer_length, cookie->buffer, &cookie->num_files);
+
+        if (rc != 0 && rc != VERR_NO_MORE_FILES)
+        {
+            dprintf(FS_NAME ": vboxCallDirInfo failed: %d\n", rc);
+            free(cookie->buffer_start);
+            cookie->buffer_start = NULL;
+            return vbox_err_to_haiku_err(rc);
+        }
+
+        if (rc == VERR_NO_MORE_FILES)
+        {
+            free(cookie->buffer_start);
+            cookie->buffer_start = NULL;
+            cookie->has_more_files = false;
+            return B_ENTRY_NOT_FOUND;
+        }
+    }
+
+    if (bufferSize <= sizeof(struct dirent) + cookie->buffer->name.u16Length)
+    {
+        dprintf("hit end of buffer\n");
+        return B_BUFFER_OVERFLOW;
+    }
+
+    PSHFLSTRING name1 = clone_shflstring(&cookie->buffer->name);
+    if (!name1)
+    {
+        dprintf(FS_NAME ": make_shflstring() failed\n");
+        return B_NO_MEMORY;
+    }
+
+    vboxsf_vnode* new_vnode;
+    int rv = vboxsf_new_vnode(&volume->map, build_path(vnode, name1->String.utf8), name1, &new_vnode);
+    if (rv != B_OK)
+    {
+        dprintf(FS_NAME ": vboxsf_new_vnode() failed\n");
+        return rv;
+    }
+    buffer->d_dev = 0;
+    buffer->d_pdev = 0;
+    buffer->d_ino = new_vnode->vnode;
+    buffer->d_pino = vnode->vnode;
+    buffer->d_reclen = sizeof(struct dirent) + cookie->buffer->name.u16Length;
+    strncpy(buffer->d_name, cookie->buffer->name.String.utf8, NAME_MAX);
+
+    size_t size = offsetof(SHFLDIRINFO, name.String) + cookie->buffer->name.u16Size;
+    cookie->buffer = ((void*)cookie->buffer + size);
+    cookie->index++;
+
+    if (cookie->index >= cookie->num_files)
+    {
+        // hit end of this buffer, next call will reallocate a new one
+        free(cookie->buffer_start);
+        cookie->buffer_start = cookie->buffer = NULL;
+    }
+    return B_OK;
+}
+
 
 status_t vboxsf_read_dir(fs_volume* _volume, fs_vnode* _vnode, void* _cookie,
-        struct dirent* buffer, size_t bufferSize, uint32* _num) {
-        vboxsf_dir_cookie* cookie = _cookie;
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_vnode* vnode = _vnode->private_node;
-        uint32 num_read = 0;
-        status_t rv = B_OK;
-
-        for (num_read = 0; num_read < *_num && cookie->has_more_files; num_read++) {
-                rv = vboxsf_read_dir_1(volume, vnode, cookie, buffer, bufferSize);
-                if (rv == B_BUFFER_OVERFLOW || rv == B_ENTRY_NOT_FOUND) {
-                        // hit end of at least one of the buffers - not really an error
-                        rv = B_OK;
-                        break;
-                }
-                bufferSize -= buffer->d_reclen;
-                buffer = ((void*)(buffer)) + buffer->d_reclen;
-        }
-
-        *_num = num_read;
-        return rv;
-}
-
-status_t vboxsf_free_dir_cookie(fs_volume* _volume, fs_vnode* vnode, void* _cookie) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_dir_cookie* cookie = _cookie;
-
-        vboxCallClose(&g_clientHandle, &volume->map, cookie->handle);
-        free(cookie->path);
-        free(cookie);
-
-        return B_OK;
-}
-
-status_t vboxsf_read_fs_info(fs_volume* _volume, struct fs_info* info) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        SHFLVOLINFO volume_info;
-        uint32_t bytes = sizeof(SHFLVOLINFO);
-
-        int rc = vboxCallFSInfo(&g_clientHandle, &volume->map, 0,
-                (SHFL_INFO_GET | SHFL_INFO_VOLUME), &bytes, (PSHFLDIRINFO)&volume_info);
-
-        if (RT_FAILURE(rc)) {
-                dprintf(FS_NAME ": vboxCallFSInfo failed (%d)\n", rc);
-                return vbox_err_to_haiku_err(rc);
-        }
-
-        info->flags = B_FS_IS_PERSISTENT;
-        if (volume_info.fsProperties.fReadOnly)
-                info->flags |= B_FS_IS_READONLY;
-
-        info->dev = 0;
-        info->root = 1;
-        info->block_size = volume_info.ulBytesPerAllocationUnit;
-        info->io_size = volume_info.ulBytesPerAllocationUnit;
-        info->total_blocks = volume_info.ullTotalAllocationBytes / info->block_size;
-        info->free_blocks = volume_info.ullAvailableAllocationBytes / info->block_size;
-        info->total_nodes = LONGLONG_MAX;
-        info->free_nodes = LONGLONG_MAX;
-        strcpy(info->volume_name, "VBox share");
-        return B_OK;
-}
-
-status_t vboxsf_lookup(fs_volume* _volume, fs_vnode* dir, const char* name, ino_t* _id) {
-        dprintf(FS_NAME ": lookup %s\n", name);
-        vboxsf_volume* volume = _volume->private_volume;
-        SHFLCREATEPARMS params;
-
-        RT_ZERO(params);
-        params.Handle = SHFL_HANDLE_NIL;
-        params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
-
-        PSHFLSTRING path = build_path(dir->private_node, name);
-        if (!path) {
-                dprintf(FS_NAME ": make_shflstring() failed\n");
-                return B_NO_MEMORY;
-        }
-
-        int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
-        if (RT_SUCCESS(rc)) {
-                if (params.Result == SHFL_FILE_EXISTS) {
-                        vboxsf_vnode* vn;
-                        status_t rv = vboxsf_new_vnode(&volume->map, path, path, &vn);
-                        if (rv == B_OK) {
-                                *_id = vn->vnode;
-                                rv = publish_vnode(_volume, vn->vnode, vn, &vboxsf_vnode_ops, mode_from_fmode(params.Info.Attr.fMode), 0);
-                        }
-                        return rv;
-                }
-                else {
-                        free(path);
-                        return B_ENTRY_NOT_FOUND;
-                }
-        }
-        else {
-                free(path);
-                dprintf(FS_NAME ": vboxCallCreate: %d\n", rc);
-                return vbox_err_to_haiku_err(rc);
-        }
-}
-
-mode_t mode_from_fmode(RTFMODE fMode) {
-        mode_t m = 0;
-
-        if (RTFS_IS_DIRECTORY(fMode))
-                m |= S_IFDIR;
-        else if (RTFS_IS_FILE(fMode))
-                m |= S_IFREG;
-        else if (RTFS_IS_FIFO(fMode))
-                m |= S_IFIFO;
-        else if (RTFS_IS_DEV_CHAR(fMode))
-                m |= S_IFCHR;
-        else if (RTFS_IS_DEV_BLOCK(fMode))
-                m |= S_IFBLK;
-        else if (RTFS_IS_SYMLINK(fMode))
-                m |= S_IFLNK;
-        else if (RTFS_IS_SOCKET(fMode))
-                m |= S_IFSOCK;
-
-        if (fMode & RTFS_UNIX_IRUSR)
-                m |= S_IRUSR;
-        if (fMode & RTFS_UNIX_IWUSR)
-                m |= S_IWUSR;
-        if (fMode & RTFS_UNIX_IXUSR)
-                m |= S_IXUSR;
-        if (fMode & RTFS_UNIX_IRGRP)
-                m |= S_IRGRP;
-        if (fMode & RTFS_UNIX_IWGRP)
-                m |= S_IWGRP;
-        if (fMode & RTFS_UNIX_IXGRP)
-                m |= S_IXGRP;
-        if (fMode & RTFS_UNIX_IROTH)
-                m |= S_IROTH;
-        if (fMode & RTFS_UNIX_IWOTH)
-                m |= S_IWOTH;
-        if (fMode & RTFS_UNIX_IXOTH)
-                m |= S_IXOTH;
-        if (fMode & RTFS_UNIX_ISUID)
-                m |= S_ISUID;
-        if (fMode & RTFS_UNIX_ISGID)
-                m |= S_ISGID;
-        if (fMode & RTFS_UNIX_ISTXT)
-                m |= S_ISVTX;
-
-        return m;
-}
-
-status_t vboxsf_open(fs_volume* _volume, fs_vnode* _vnode, int openMode, void** _cookie) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_vnode* vnode = _vnode->private_node;
-
-        dprintf(FS_NAME ": open %s (mode=%x)\n", vnode->path->String.utf8, openMode);
-
-        SHFLCREATEPARMS params;
-
-        RT_ZERO(params);
-        params.Handle = SHFL_HANDLE_NIL;
-
-        if (openMode & O_RDWR)
-                params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
-        else if (openMode & O_RDONLY)
-                params.CreateFlags |= SHFL_CF_ACCESS_READ;
-        else if (openMode & O_WRONLY)
-                params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
-
-        if (openMode & O_APPEND)
-                params.CreateFlags |= SHFL_CF_ACCESS_APPEND;
-
-        if (openMode & O_CREAT) {
-                params.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
-                if (openMode & O_EXCL)
-                        params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
-                else if (openMode & O_TRUNC)
-                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
-                else
-                        params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
-        }
-        else {
-                params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
-                if (openMode & O_TRUNC)
-                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
-                else
-                        params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
-        }
-
-        int rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
-        if (!RT_SUCCESS(rc)) {
-                dprintf("vboxCallCreate returned %d\n", rc);
-                return vbox_err_to_haiku_err(rc);
-        }
-
-        vboxsf_file_cookie* cookie = malloc(sizeof(vboxsf_file_cookie));
-        if (!cookie) {
-                dprintf("couldn't allocate file cookie\n");
-                return B_NO_MEMORY;
-        }
-
-        cookie->handle = params.Handle;
-        cookie->path = vnode->path;
-
-        *_cookie = cookie;
-
-        return B_OK;
-}
-
-status_t vboxsf_create(fs_volume* _volume, fs_vnode* _dir, const char *name, int openMode, int perms, void **_cookie, ino_t *_newVnodeID) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        SHFLCREATEPARMS params;
-
-        RT_ZERO(params);
-        params.Handle = SHFL_HANDLE_NIL;
-
-        if (openMode & O_RDWR)
-                params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
-        else if (openMode & O_RDONLY)
-                params.CreateFlags |= SHFL_CF_ACCESS_READ;
-        else if (openMode & O_WRONLY)
-                params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
-
-        if (openMode & O_APPEND)
-                params.CreateFlags |= SHFL_CF_ACCESS_APPEND;
-
-        if (openMode & O_CREAT) {
-                params.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
-                if (openMode & O_EXCL)
-                        params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
-                else if (openMode & O_TRUNC)
-                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
-                else
-                        params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
-        }
-        else {
-                params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
-                if (openMode & O_TRUNC)
-                        params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
-                else
-                        params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
-        }
-
-        PSHFLSTRING path = build_path(_dir->private_node, name);
-        int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
-
-        if (!RT_SUCCESS(rc)) {
-                dprintf("vboxCallCreate returned %d\n", rc);
-                free(path);
-                return vbox_err_to_haiku_err(rc);
-        }
-
-        vboxsf_file_cookie* cookie = malloc(sizeof(vboxsf_file_cookie));
-        if (!cookie) {
-                dprintf("couldn't allocate file cookie\n");
-                free(path);
-                return B_NO_MEMORY;
-        }
-
-        cookie->handle = params.Handle;
-        cookie->path = path;
-
-        *_cookie = cookie;
-        return vboxsf_lookup(_volume, _dir, name, _newVnodeID);
-}
-
-status_t vboxsf_close(fs_volume* _volume, fs_vnode* _vnode, void* _cookie) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_file_cookie* cookie = _cookie;
-
-        int rc = vboxCallClose(&g_clientHandle, &volume->map, cookie->handle);
-        dprintf("vboxCallClose returned %d\n", rc);
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_rewind_dir(fs_volume* _volume, fs_vnode* _vnode, void* _cookie) {
-        vboxsf_dir_cookie* cookie = _cookie;
-        cookie->index = 0;
-        return B_OK;
-}
-
-status_t vboxsf_close_dir(fs_volume *volume, fs_vnode *vnode, void *cookie) {
-        return B_OK;
-}
-
-status_t vboxsf_free_cookie(fs_volume *volume, fs_vnode *vnode, void *_cookie) {
-        vboxsf_dir_cookie* cookie = _cookie;
-        free(cookie);
-        return B_OK;
-}
-
-status_t vboxsf_read(fs_volume* _volume, fs_vnode* _vnode, void* _cookie, off_t pos, void *buffer, size_t *length) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_vnode* vnode = _vnode->private_node;
-        vboxsf_file_cookie* cookie = _cookie;
-
-        if (*length > 0xFFFFFFFF) {
-                *length = 0xFFFFFFFF;
-        }
-
-        uint32_t l = *length;
-        void* other_buffer = malloc(l); // TODO map the user memory into kernel space here for efficiency
-        int rc = vboxCallRead(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false);
-        memcpy(buffer, other_buffer, l);
-        free(other_buffer);
-
-        dprintf("vboxCallRead returned %d\n", rc);
-        *length = l;
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_write(fs_volume* _volume, fs_vnode* _vnode, void* _cookie, off_t pos, const void *buffer, size_t *length) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_vnode* vnode = _vnode->private_node;
-        vboxsf_file_cookie* cookie = _cookie;
-
-        if (*length > 0xFFFFFFFF) {
-                *length = 0xFFFFFFFF;
-        }
-
-        uint32_t l = *length;
-        void* other_buffer = malloc(l); // TODO map the user memory into kernel space here for efficiency
-        memcpy(other_buffer, buffer, l);
-        int rc = vboxCallWrite(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false);
-        free(other_buffer);
-
-        *length = l;
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_write_stat(fs_volume *volume, fs_vnode *vnode, const struct stat *stat, uint32 statMask) {
-        // the host handles updating the stat info - in the guest, this is a no-op
-        return B_OK;
-}
-
-status_t vboxsf_create_dir(fs_volume *_volume, fs_vnode *parent, const char *name, int perms) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        SHFLCREATEPARMS params;
-        params.Handle = 0;
-        params.Info.cbObject = 0;
-        params.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_CREATE_IF_NEW |
-            SHFL_CF_ACT_FAIL_IF_EXISTS | SHFL_CF_ACCESS_READ;
-
-        PSHFLSTRING path = build_path(parent->private_node, name);
-        int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
-        free(path);
-        if (params.Handle == SHFL_HANDLE_NIL) {
-                return vbox_err_to_haiku_err(rc);
-        }
-        else {
-                vboxCallClose(&g_clientHandle, &volume->map, params.Handle);
-                return B_OK;
-        }
-}
-
-status_t vboxsf_remove_dir(fs_volume *_volume, fs_vnode *parent, const char *name) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        PSHFLSTRING path = build_path(parent->private_node, name);
-        int rc = vboxCallRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_DIR);
-        free(path);
-
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_unlink(fs_volume *_volume, fs_vnode *parent, const char *name) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        PSHFLSTRING path = build_path(parent->private_node, name);
-        int rc = vboxCallRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_FILE);
-        free(path);
-
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_link(fs_volume *volume, fs_vnode *dir, const char *name, fs_vnode *vnode) {
-        return B_UNSUPPORTED;
-}
-
-status_t vboxsf_rename(fs_volume* _volume, fs_vnode* fromDir, const char* fromName, fs_vnode* toDir, const char* toName) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        PSHFLSTRING oldpath = build_path(fromDir->private_node, fromName);
-        PSHFLSTRING newpath = build_path(toDir->private_node, toName);
-        int rc = vboxCallRename(&g_clientHandle, &volume->map, oldpath, newpath, SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
-        free(oldpath);
-        free(newpath);
-
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_create_symlink(fs_volume* _volume, fs_vnode* dir, const char* name, const char* path, int mode) {
-        vboxsf_volume* volume = _volume->private_volume;
-
-        PSHFLSTRING target = make_shflstring(path);
-        PSHFLSTRING linkpath = build_path(dir->private_node, name);
-        SHFLFSOBJINFO stuff;
-        RT_ZERO(stuff);
-
-        int rc = vboxCallSymlink(&g_clientHandle, &volume->map, linkpath, target, &stuff);
-
-        free(target);
-        free(linkpath);
-
-        return vbox_err_to_haiku_err(rc);
-}
-
-status_t vboxsf_read_symlink(fs_volume* _volume, fs_vnode* link, char* buffer, size_t* _bufferSize) {
-        vboxsf_volume* volume = _volume->private_volume;
-        vboxsf_vnode* vnode = link->private_node;
-
-        int rc = vboxReadLink(&g_clientHandle, &volume->map, vnode->path, *_bufferSize, buffer);
-        *_bufferSize = strlen(buffer);
-
-        return vbox_err_to_haiku_err(rc);
-}
+    struct dirent* buffer, size_t bufferSize, uint32* _num)
+{
+    vboxsf_dir_cookie* cookie = _cookie;
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_vnode* vnode = _vnode->private_node;
+    uint32 num_read = 0;
+    status_t rv = B_OK;
+
+    for (num_read = 0; num_read < *_num && cookie->has_more_files; num_read++)
+    {
+        rv = vboxsf_read_dir_1(volume, vnode, cookie, buffer, bufferSize);
+        if (rv == B_BUFFER_OVERFLOW || rv == B_ENTRY_NOT_FOUND)
+        {
+            // hit end of at least one of the buffers - not really an error
+            rv = B_OK;
+            break;
+        }
+        bufferSize -= buffer->d_reclen;
+        buffer = ((void*)(buffer)) + buffer->d_reclen;
+    }
+
+    *_num = num_read;
+    return rv;
+}
+
+
+status_t vboxsf_free_dir_cookie(fs_volume* _volume, fs_vnode* vnode, void* _cookie)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_dir_cookie* cookie = _cookie;
+
+    vboxCallClose(&g_clientHandle, &volume->map, cookie->handle);
+    free(cookie->path);
+    free(cookie);
+
+    return B_OK;
+}
+
+
+status_t vboxsf_read_fs_info(fs_volume* _volume, struct fs_info* info)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    SHFLVOLINFO volume_info;
+    uint32_t bytes = sizeof(SHFLVOLINFO);
+
+    int rc = vboxCallFSInfo(&g_clientHandle, &volume->map, 0,
+        (SHFL_INFO_GET | SHFL_INFO_VOLUME), &bytes, (PSHFLDIRINFO)&volume_info);
+
+    if (RT_FAILURE(rc))
+    {
+        dprintf(FS_NAME ": vboxCallFSInfo failed (%d)\n", rc);
+        return vbox_err_to_haiku_err(rc);
+    }
+
+    info->flags = B_FS_IS_PERSISTENT;
+    if (volume_info.fsProperties.fReadOnly)
+        info->flags |= B_FS_IS_READONLY;
+
+    info->dev = 0;
+    info->root = 1;
+    info->block_size = volume_info.ulBytesPerAllocationUnit;
+    info->io_size = volume_info.ulBytesPerAllocationUnit;
+    info->total_blocks = volume_info.ullTotalAllocationBytes / info->block_size;
+    info->free_blocks = volume_info.ullAvailableAllocationBytes / info->block_size;
+    info->total_nodes = LONGLONG_MAX;
+    info->free_nodes = LONGLONG_MAX;
+    strcpy(info->volume_name, "VBox share");
+    return B_OK;
+}
+
+
+status_t vboxsf_lookup(fs_volume* _volume, fs_vnode* dir, const char* name, ino_t* _id)
+{
+    dprintf(FS_NAME ": lookup %s\n", name);
+    vboxsf_volume* volume = _volume->private_volume;
+    SHFLCREATEPARMS params;
+
+    RT_ZERO(params);
+    params.Handle = SHFL_HANDLE_NIL;
+    params.CreateFlags = SHFL_CF_LOOKUP | SHFL_CF_ACT_FAIL_IF_NEW;
+
+    PSHFLSTRING path = build_path(dir->private_node, name);
+    if (!path)
+    {
+        dprintf(FS_NAME ": make_shflstring() failed\n");
+        return B_NO_MEMORY;
+    }
+
+    int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
+    if (RT_SUCCESS(rc))
+    {
+        if (params.Result == SHFL_FILE_EXISTS)
+        {
+            vboxsf_vnode* vn;
+            status_t rv = vboxsf_new_vnode(&volume->map, path, path, &vn);
+            if (rv == B_OK)
+            {
+                *_id = vn->vnode;
+                rv = publish_vnode(_volume, vn->vnode, vn, &vboxsf_vnode_ops, mode_from_fmode(params.Info.Attr.fMode), 0);
+            }
+            return rv;
+        }
+        else
+        {
+            free(path);
+            return B_ENTRY_NOT_FOUND;
+        }
+    }
+    else
+    {
+        free(path);
+        dprintf(FS_NAME ": vboxCallCreate: %d\n", rc);
+        return vbox_err_to_haiku_err(rc);
+    }
+}
+
+
+mode_t mode_from_fmode(RTFMODE fMode)
+{
+    mode_t m = 0;
+
+    if (RTFS_IS_DIRECTORY(fMode))
+        m |= S_IFDIR;
+    else if (RTFS_IS_FILE(fMode))
+        m |= S_IFREG;
+    else if (RTFS_IS_FIFO(fMode))
+        m |= S_IFIFO;
+    else if (RTFS_IS_DEV_CHAR(fMode))
+        m |= S_IFCHR;
+    else if (RTFS_IS_DEV_BLOCK(fMode))
+        m |= S_IFBLK;
+    else if (RTFS_IS_SYMLINK(fMode))
+        m |= S_IFLNK;
+    else if (RTFS_IS_SOCKET(fMode))
+        m |= S_IFSOCK;
+
+    if (fMode & RTFS_UNIX_IRUSR)
+        m |= S_IRUSR;
+    if (fMode & RTFS_UNIX_IWUSR)
+        m |= S_IWUSR;
+    if (fMode & RTFS_UNIX_IXUSR)
+        m |= S_IXUSR;
+    if (fMode & RTFS_UNIX_IRGRP)
+        m |= S_IRGRP;
+    if (fMode & RTFS_UNIX_IWGRP)
+        m |= S_IWGRP;
+    if (fMode & RTFS_UNIX_IXGRP)
+        m |= S_IXGRP;
+    if (fMode & RTFS_UNIX_IROTH)
+        m |= S_IROTH;
+    if (fMode & RTFS_UNIX_IWOTH)
+        m |= S_IWOTH;
+    if (fMode & RTFS_UNIX_IXOTH)
+        m |= S_IXOTH;
+    if (fMode & RTFS_UNIX_ISUID)
+        m |= S_ISUID;
+    if (fMode & RTFS_UNIX_ISGID)
+        m |= S_ISGID;
+    if (fMode & RTFS_UNIX_ISTXT)
+        m |= S_ISVTX;
+
+    return m;
+}
+
+
+status_t vboxsf_open(fs_volume* _volume, fs_vnode* _vnode, int openMode, void** _cookie)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_vnode* vnode = _vnode->private_node;
+
+    dprintf(FS_NAME ": open %s (mode=%x)\n", vnode->path->String.utf8, openMode);
+
+    SHFLCREATEPARMS params;
+
+    RT_ZERO(params);
+    params.Handle = SHFL_HANDLE_NIL;
+
+    if (openMode & O_RDWR)
+        params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
+    else if (openMode & O_RDONLY)
+        params.CreateFlags |= SHFL_CF_ACCESS_READ;
+    else if (openMode & O_WRONLY)
+        params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
+
+    if (openMode & O_APPEND)
+        params.CreateFlags |= SHFL_CF_ACCESS_APPEND;
+
+    if (openMode & O_CREAT)
+    {
+        params.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
+        if (openMode & O_EXCL)
+            params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
+        else if (openMode & O_TRUNC)
+            params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
+        else
+            params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+    }
+    else
+    {
+        params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
+        if (openMode & O_TRUNC)
+            params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
+        else
+            params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+    }
+
+    int rc = vboxCallCreate(&g_clientHandle, &volume->map, vnode->path, &params);
+    if (!RT_SUCCESS(rc))
+    {
+        dprintf("vboxCallCreate returned %d\n", rc);
+        return vbox_err_to_haiku_err(rc);
+    }
+
+    vboxsf_file_cookie* cookie = malloc(sizeof(vboxsf_file_cookie));
+    if (!cookie)
+    {
+        dprintf("couldn't allocate file cookie\n");
+        return B_NO_MEMORY;
+    }
+
+    cookie->handle = params.Handle;
+    cookie->path = vnode->path;
+
+    *_cookie = cookie;
+
+    return B_OK;
+}
+
+
+status_t vboxsf_create(fs_volume* _volume, fs_vnode* _dir, const char *name, int openMode, int perms, void **_cookie, ino_t *_newVnodeID)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    SHFLCREATEPARMS params;
+
+    RT_ZERO(params);
+    params.Handle = SHFL_HANDLE_NIL;
+
+    if (openMode & O_RDWR)
+        params.CreateFlags |= SHFL_CF_ACCESS_READWRITE;
+    else if (openMode & O_RDONLY)
+        params.CreateFlags |= SHFL_CF_ACCESS_READ;
+    else if (openMode & O_WRONLY)
+        params.CreateFlags |= SHFL_CF_ACCESS_WRITE;
+
+    if (openMode & O_APPEND)
+        params.CreateFlags |= SHFL_CF_ACCESS_APPEND;
+
+    if (openMode & O_CREAT)
+    {
+        params.CreateFlags |= SHFL_CF_ACT_CREATE_IF_NEW;
+        if (openMode & O_EXCL)
+            params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_EXISTS;
+        else if (openMode & O_TRUNC)
+            params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
+        else
+            params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+    }
+    else
+    {
+        params.CreateFlags |= SHFL_CF_ACT_FAIL_IF_NEW;
+        if (openMode & O_TRUNC)
+            params.CreateFlags |= SHFL_CF_ACT_OVERWRITE_IF_EXISTS;
+        else
+            params.CreateFlags |= SHFL_CF_ACT_OPEN_IF_EXISTS;
+    }
+
+    PSHFLSTRING path = build_path(_dir->private_node, name);
+    int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
+
+    if (!RT_SUCCESS(rc))
+    {
+        dprintf("vboxCallCreate returned %d\n", rc);
+        free(path);
+        return vbox_err_to_haiku_err(rc);
+    }
+
+    vboxsf_file_cookie* cookie = malloc(sizeof(vboxsf_file_cookie));
+    if (!cookie)
+    {
+        dprintf("couldn't allocate file cookie\n");
+        free(path);
+        return B_NO_MEMORY;
+    }
+
+    cookie->handle = params.Handle;
+    cookie->path = path;
+
+    *_cookie = cookie;
+    return vboxsf_lookup(_volume, _dir, name, _newVnodeID);
+}
+
+
+status_t vboxsf_close(fs_volume* _volume, fs_vnode* _vnode, void* _cookie)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_file_cookie* cookie = _cookie;
+
+    int rc = vboxCallClose(&g_clientHandle, &volume->map, cookie->handle);
+    dprintf("vboxCallClose returned %d\n", rc);
+    return vbox_err_to_haiku_err(rc);
+}
+
+
+status_t vboxsf_rewind_dir(fs_volume* _volume, fs_vnode* _vnode, void* _cookie)
+{
+    vboxsf_dir_cookie* cookie = _cookie;
+    cookie->index = 0;
+    return B_OK;
+}
+
+
+status_t vboxsf_close_dir(fs_volume *volume, fs_vnode *vnode, void *cookie)
+{
+    return B_OK;
+}
+
+
+status_t vboxsf_free_cookie(fs_volume *volume, fs_vnode *vnode, void *_cookie)
+{
+    vboxsf_dir_cookie* cookie = _cookie;
+    free(cookie);
+    return B_OK;
+}
+
+status_t vboxsf_read(fs_volume* _volume, fs_vnode* _vnode, void* _cookie, off_t pos, void *buffer, size_t *length)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_vnode* vnode = _vnode->private_node;
+    vboxsf_file_cookie* cookie = _cookie;
+
+    if (*length > 0xFFFFFFFF)
+        *length = 0xFFFFFFFF;
+
+    uint32_t l = *length;
+    void* other_buffer = malloc(l); // TODO map the user memory into kernel space here for efficiency
+    int rc = vboxCallRead(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false);
+    memcpy(buffer, other_buffer, l);
+    free(other_buffer);
+
+    dprintf("vboxCallRead returned %d\n", rc);
+    *length = l;
+    return vbox_err_to_haiku_err(rc);
+}
+
+
+status_t vboxsf_write(fs_volume* _volume, fs_vnode* _vnode, void* _cookie, off_t pos, const void *buffer, size_t *length)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_vnode* vnode = _vnode->private_node;
+    vboxsf_file_cookie* cookie = _cookie;
+
+    if (*length > 0xFFFFFFFF)
+        *length = 0xFFFFFFFF;
+
+    uint32_t l = *length;
+    void* other_buffer = malloc(l); // TODO map the user memory into kernel space here for efficiency
+    memcpy(other_buffer, buffer, l);
+    int rc = vboxCallWrite(&g_clientHandle, &volume->map, cookie->handle, pos, &l, other_buffer, false);
+    free(other_buffer);
+
+    *length = l;
+    return vbox_err_to_haiku_err(rc);
+}
+
+
+status_t vboxsf_write_stat(fs_volume *volume, fs_vnode *vnode, const struct stat *stat, uint32 statMask)
+{
+    // the host handles updating the stat info - in the guest, this is a no-op
+    return B_OK;
+}
+
+
+status_t vboxsf_create_dir(fs_volume *_volume, fs_vnode *parent, const char *name, int perms)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    SHFLCREATEPARMS params;
+    params.Handle = 0;
+    params.Info.cbObject = 0;
+    params.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_CREATE_IF_NEW |
+        SHFL_CF_ACT_FAIL_IF_EXISTS | SHFL_CF_ACCESS_READ;
+
+    PSHFLSTRING path = build_path(parent->private_node, name);
+    int rc = vboxCallCreate(&g_clientHandle, &volume->map, path, &params);
+    free(path);
+    if (params.Handle == SHFL_HANDLE_NIL)
+        return vbox_err_to_haiku_err(rc);
+    else
+    {
+        vboxCallClose(&g_clientHandle, &volume->map, params.Handle);
+        return B_OK;
+    }
+}
+
+
+status_t vboxsf_remove_dir(fs_volume *_volume, fs_vnode *parent, const char *name)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    PSHFLSTRING path = build_path(parent->private_node, name);
+    int rc = vboxCallRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_DIR);
+    free(path);
+
+    return vbox_err_to_haiku_err(rc);
+}
+
+
+status_t vboxsf_unlink(fs_volume *_volume, fs_vnode *parent, const char *name)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    PSHFLSTRING path = build_path(parent->private_node, name);
+    int rc = vboxCallRemove(&g_clientHandle, &volume->map, path, SHFL_REMOVE_FILE);
+    free(path);
+
+    return vbox_err_to_haiku_err(rc);
+}
+
+status_t vboxsf_link(fs_volume *volume, fs_vnode *dir, const char *name, fs_vnode *vnode)
+{
+    return B_UNSUPPORTED;
+}
+
+
+status_t vboxsf_rename(fs_volume* _volume, fs_vnode* fromDir, const char* fromName, fs_vnode* toDir, const char* toName)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    PSHFLSTRING oldpath = build_path(fromDir->private_node, fromName);
+    PSHFLSTRING newpath = build_path(toDir->private_node, toName);
+    int rc = vboxCallRename(&g_clientHandle, &volume->map, oldpath, newpath, SHFL_RENAME_FILE | SHFL_RENAME_REPLACE_IF_EXISTS);
+    free(oldpath);
+    free(newpath);
+
+    return vbox_err_to_haiku_err(rc);
+}
+
+
+status_t vboxsf_create_symlink(fs_volume* _volume, fs_vnode* dir, const char* name, const char* path, int mode)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+
+    PSHFLSTRING target = make_shflstring(path);
+    PSHFLSTRING linkpath = build_path(dir->private_node, name);
+    SHFLFSOBJINFO stuff;
+    RT_ZERO(stuff);
+
+    int rc = vboxCallSymlink(&g_clientHandle, &volume->map, linkpath, target, &stuff);
+
+    free(target);
+    free(linkpath);
+
+    return vbox_err_to_haiku_err(rc);
+}
+
+
+status_t vboxsf_read_symlink(fs_volume* _volume, fs_vnode* link, char* buffer, size_t* _bufferSize)
+{
+    vboxsf_volume* volume = _volume->private_volume;
+    vboxsf_vnode* vnode = link->private_node;
+
+    int rc = vboxReadLink(&g_clientHandle, &volume->map, vnode->path, *_bufferSize, buffer);
+    *_bufferSize = strlen(buffer);
+
+    return vbox_err_to_haiku_err(rc);
+}
+
 
 // TODO move this into the runtime
-status_t vbox_err_to_haiku_err(int rc) {
-        switch (rc) {
-                case VINF_SUCCESS: return B_OK;
-                case VERR_INVALID_POINTER: return B_BAD_ADDRESS;
-                case VERR_INVALID_PARAMETER: return B_BAD_VALUE;
-                case VERR_PERMISSION_DENIED: return B_PERMISSION_DENIED;
-                case VERR_NOT_IMPLEMENTED: return B_UNSUPPORTED;
-                case VERR_FILE_NOT_FOUND: return B_ENTRY_NOT_FOUND;
-
-                case SHFL_FILE_EXISTS: return B_FILE_EXISTS;
-                case SHFL_PATH_NOT_FOUND:
-                case SHFL_FILE_NOT_FOUND: return B_ENTRY_NOT_FOUND;
-
-                default: return B_ERROR;
-        }
-}
-
-static status_t std_ops(int32 op, ...) {
-        switch(op) {
-        case B_MODULE_INIT:
-                dprintf(MODULE_NAME ": B_MODULE_INIT\n");
-                return init_module();
-        case B_MODULE_UNINIT:
-                dprintf(MODULE_NAME ": B_MODULE_UNINIT\n");
-                uninit_module();
-                return B_OK;
-        default:
-                return B_ERROR;
-        }
-}
-
-static fs_volume_ops vboxsf_volume_ops = {
-        unmount,
-
-        vboxsf_read_fs_info, // read_fs_info
-        NULL, // write_fs_info
-        NULL, // sync
-
-        vboxsf_get_vnode, // get_vnode
-
-        NULL, // open_index_dir
-        NULL, // close_index_dir
-        NULL, // free_index_dir_cookie
-        NULL, // read_index_dir
-        NULL, // rewind_index_dir
-
-        NULL, // create_index
-        NULL, // remove_index
-        NULL, // read_index_stat
-
-        NULL, // open_query
-        NULL, // close_query
-        NULL, // free_query_cookie
-        NULL, // read_query
-        NULL, // rewind_query
-
-        NULL, // all_layers_mounted
-        NULL, // create_sub_vnode
-        NULL, // delete_sub_vnode
+status_t vbox_err_to_haiku_err(int rc)
+{
+    switch (rc) {
+        case VINF_SUCCESS: return B_OK;
+        case VERR_INVALID_POINTER: return B_BAD_ADDRESS;
+        case VERR_INVALID_PARAMETER: return B_BAD_VALUE;
+        case VERR_PERMISSION_DENIED: return B_PERMISSION_DENIED;
+        case VERR_NOT_IMPLEMENTED: return B_UNSUPPORTED;
+        case VERR_FILE_NOT_FOUND: return B_ENTRY_NOT_FOUND;
+
+        case SHFL_FILE_EXISTS: return B_FILE_EXISTS;
+        case SHFL_PATH_NOT_FOUND:
+        case SHFL_FILE_NOT_FOUND: return B_ENTRY_NOT_FOUND;
+
+        default: return B_ERROR;
+    }
+}
+
+
+static status_t std_ops(int32 op, ...)
+{
+    switch(op)
+    {
+        case B_MODULE_INIT:
+            dprintf(MODULE_NAME ": B_MODULE_INIT\n");
+            return init_module();
+        case B_MODULE_UNINIT:
+            dprintf(MODULE_NAME ": B_MODULE_UNINIT\n");
+            uninit_module();
+            return B_OK;
+        default:
+            return B_ERROR;
+    }
+}
+
+
+static fs_volume_ops vboxsf_volume_ops =
+{
+    unmount,
+    vboxsf_read_fs_info, // read_fs_info
+    NULL, // write_fs_info
+    NULL, // sync
+    vboxsf_get_vnode, // get_vnode
+    NULL, // open_index_dir
+    NULL, // close_index_dir
+    NULL, // free_index_dir_cookie
+    NULL, // read_index_dir
+    NULL, // rewind_index_dir
+    NULL, // create_index
+    NULL, // remove_index
+    NULL, // read_index_stat
+    NULL, // open_query
+    NULL, // close_query
+    NULL, // free_query_cookie
+    NULL, // read_query
+    NULL, // rewind_query
+    NULL, // all_layers_mounted
+    NULL, // create_sub_vnode
+    NULL, // delete_sub_vnode
 };
 
-static fs_vnode_ops vboxsf_vnode_ops = {
-        vboxsf_lookup, // lookup
-        NULL, // get_vnode_name
-        vboxsf_put_vnode, // put_vnode
-        NULL, // remove_vnode
-        NULL, // can_page
-        NULL, // read_pages
-        NULL, // write_pages
-        NULL, // io
-        NULL, // cancel_io
-        NULL, // get_file_map
-        NULL, // ioctl
-        NULL, // set_flags
-        NULL, // select
-        NULL, // deselect
-        NULL, // fsync
-        vboxsf_read_symlink, // read_symlink
-        vboxsf_create_symlink, // create_symlink
-        vboxsf_link, // link
-        vboxsf_unlink, // unlink
-        vboxsf_rename, // rename
-        NULL, // access
-        vboxsf_read_stat, // read_stat
-        vboxsf_write_stat, // write_stat
-        NULL, // preallocate
-        vboxsf_create, // create
-        vboxsf_open, // open
-        vboxsf_close, // close
-        vboxsf_free_cookie, // free_cookie
-        vboxsf_read, // read
-        vboxsf_write, // write
-        vboxsf_create_dir, // create_dir
-        vboxsf_remove_dir, // remove_dir
-        vboxsf_open_dir, // open_dir
-        vboxsf_close_dir, // close_dir
-        vboxsf_free_dir_cookie, // free_dir_cookie
-        vboxsf_read_dir, // read_dir
-        vboxsf_rewind_dir, // rewind_dir
-        NULL, // open_attr_dir
-        NULL, // close_attr_dir
-        NULL, // free_attr_dir_cookie
-        NULL, // read_attr_dir
-        NULL, // rewind_attr_dir
-        NULL, // create_attr
-        NULL, // open_attr
-        NULL, // close_attr
-        NULL, // free_attr_cookie
-        NULL, // read_attr
-        NULL, // write_attr
-        NULL, // read_attr_stat
-        NULL, // write_attr_stat
-        NULL, // rename_attr
-        NULL, // remove_attr
-        NULL, // create_special_node
-        NULL, // get_super_vnode
+static fs_vnode_ops vboxsf_vnode_ops =
+{
+    vboxsf_lookup, // lookup
+    NULL, // get_vnode_name
+    vboxsf_put_vnode, // put_vnode
+    NULL, // remove_vnode
+    NULL, // can_page
+    NULL, // read_pages
+    NULL, // write_pages
+    NULL, // io
+    NULL, // cancel_io
+    NULL, // get_file_map
+    NULL, // ioctl
+    NULL, // set_flags
+    NULL, // select
+    NULL, // deselect
+    NULL, // fsync
+    vboxsf_read_symlink, // read_symlink
+    vboxsf_create_symlink, // create_symlink
+    vboxsf_link, // link
+    vboxsf_unlink, // unlink
+    vboxsf_rename, // rename
+    NULL, // access
+    vboxsf_read_stat, // read_stat
+    vboxsf_write_stat, // write_stat
+    NULL, // preallocate
+    vboxsf_create, // create
+    vboxsf_open, // open
+    vboxsf_close, // close
+    vboxsf_free_cookie, // free_cookie
+    vboxsf_read, // read
+    vboxsf_write, // write
+    vboxsf_create_dir, // create_dir
+    vboxsf_remove_dir, // remove_dir
+    vboxsf_open_dir, // open_dir
+    vboxsf_close_dir, // close_dir
+    vboxsf_free_dir_cookie, // free_dir_cookie
+    vboxsf_read_dir, // read_dir
+    vboxsf_rewind_dir, // rewind_dir
+    NULL, // open_attr_dir
+    NULL, // close_attr_dir
+    NULL, // free_attr_dir_cookie
+    NULL, // read_attr_dir
+    NULL, // rewind_attr_dir
+    NULL, // create_attr
+    NULL, // open_attr
+    NULL, // close_attr
+    NULL, // free_attr_cookie
+    NULL, // read_attr
+    NULL, // write_attr
+    NULL, // read_attr_stat
+    NULL, // write_attr_stat
+    NULL, // rename_attr
+    NULL, // remove_attr
+    NULL, // create_special_node
+    NULL, // get_super_vnode
 };
 
-static file_system_module_info sVBoxSharedFileSystem = {
-        {
-                MODULE_NAME B_CURRENT_FS_API_VERSION,
-                0,
-                std_ops,
-        },
-
-        FS_NAME,                                                // short_name
-        "VirtualBox shared folders",    // pretty_name
-        0, //B_DISK_SYSTEM_SUPPORTS_WRITING,    // DDM flags
-
-        // scanning
-        NULL, // identify_partition
-        NULL, // scan_partition
-        NULL, // free_identify_partition_cookie
-        NULL,   // free_partition_content_cookie()
-
-        mount,
+static file_system_module_info sVBoxSharedFileSystem =
+{
+    {
+        MODULE_NAME B_CURRENT_FS_API_VERSION,
+        0,
+        std_ops,
+    },
+    FS_NAME,                        // short_name
+    "VirtualBox shared folders",    // pretty_name
+    0, //B_DISK_SYSTEM_SUPPORTS_WRITING,    // DDM flags
+    // scanning
+    NULL, // identify_partition
+    NULL, // scan_partition
+    NULL, // free_identify_partition_cookie
+    NULL,    // free_partition_content_cookie()
+    mount,
 };
 
-module_info *modules[] = {
-        (module_info *)&sVBoxSharedFileSystem,
-        NULL,
+module_info *modules[] =
+{
+    (module_info *)&sVBoxSharedFileSystem,
+    NULL,
 };
+

trunk/src/VBox/Additions/haiku/SharedFolders/vboxsf.h

@@ -57 +57 @@
 #include "lock.h"
 
-typedef struct vboxsf_volume {
-        VBSFMAP map;
-        ino_t rootid;
+typedef struct vboxsf_volume
+{
+    VBSFMAP map;
+    ino_t rootid;
 } vboxsf_volume;
 
-typedef struct vboxsf_vnode {
-        PVBSFMAP map;
-        PSHFLSTRING name;
-        PSHFLSTRING path;
-
-        ino_t vnode;
-        struct vboxsf_vnode* next;
+typedef struct vboxsf_vnode
+{
+    PVBSFMAP map;
+    PSHFLSTRING name;
+    PSHFLSTRING path;
+    ino_t vnode;
+    struct vboxsf_vnode* next;
 } vboxsf_vnode;
 
-typedef struct vboxsf_dir_cookie {
-        SHFLHANDLE handle;
-        PSHFLSTRING path;
-        uint32_t index;
-        bool has_more_files;
-        PSHFLDIRINFO buffer_start, buffer;
-        uint32_t buffer_length, num_files;
+typedef struct vboxsf_dir_cookie
+{
+    SHFLHANDLE handle;
+    PSHFLSTRING path;
+    uint32_t index;
+    bool has_more_files;
+    PSHFLDIRINFO buffer_start, buffer;
+    uint32_t buffer_length, num_files;
 } vboxsf_dir_cookie;
 
-typedef struct vboxsf_file_cookie {
-        SHFLHANDLE handle;
-        PSHFLSTRING path;
+typedef struct vboxsf_file_cookie
+{
+    SHFLHANDLE handle;
+    PSHFLSTRING path;
 } vboxsf_file_cookie;
 
@@ -100 +103 @@
 
 #endif
+

trunk/src/VBox/Additions/haiku/SharedFolders/vnode_cache.cpp

@@ -47 +47 @@
 #include "OpenHashTable.h"
 
-struct HashTableDefinition {
-        typedef uint32 KeyType;
-        typedef vboxsf_vnode ValueType;
+struct HashTableDefinition
+{
+    typedef uint32 KeyType;
+    typedef    vboxsf_vnode ValueType;
 
-        size_t HashKey(uint32 key) const
-        {
-                return key;
-        }
+    size_t HashKey(uint32 key) const
+    {
+        return key;
+    }
 
-        size_t Hash(vboxsf_vnode* value) const
-        {
-                return HashKey(value->vnode);
-        }
+    size_t Hash(vboxsf_vnode* value) const
+    {
+        return HashKey(value->vnode);
+    }
 
-        bool Compare(uint32 key, vboxsf_vnode* value) const
-        {
-                return value->vnode == key;
-        }
+    bool Compare(uint32 key, vboxsf_vnode* value) const
+    {
+        return value->vnode == key;
+    }
 
-        vboxsf_vnode*& GetLink(vboxsf_vnode* value) const
-        {
-                return value->next;
-        }
+    vboxsf_vnode*& GetLink(vboxsf_vnode* value) const
+    {
+        return value->next;
+    }
 };
 
@@ -76 +77 @@
 mutex g_vnodeCacheLock;
 
-extern "C" status_t vboxsf_new_vnode(PVBSFMAP map, PSHFLSTRING path, PSHFLSTRING name, vboxsf_vnode** p) {
-        vboxsf_vnode* vn = (vboxsf_vnode*)malloc(sizeof(vboxsf_vnode));
-        if (vn == NULL) {
-                return B_NO_MEMORY;
-        }
-        dprintf("creating new vnode at %p with path=%p (%s)\n", vn, path->String.utf8, path->String.utf8);
-        vn->map = map;
-        vn->path = path;
-        if (name) {
-                vn->name = name;
-        }
-        else {
-                const char* cname = strrchr((char*)path->String.utf8, '/');
-                if (!cname)
-                        vn->name = path; // no slash, assume this *is* the filename
-                else
-                        vn->name = make_shflstring(cname);
-        }
 
-        if (mutex_lock(&g_vnodeCacheLock) < B_OK) {
-                free(vn);
-                return B_ERROR;
-        }
+extern "C" status_t vboxsf_new_vnode(PVBSFMAP map, PSHFLSTRING path, PSHFLSTRING name, vboxsf_vnode** p)
+{
+    vboxsf_vnode* vn = (vboxsf_vnode*)malloc(sizeof(vboxsf_vnode));
+    if (vn == NULL)
+        return B_NO_MEMORY;
 
-        vn->vnode = g_nextVnid++;
-        *p = vn;
-        dprintf("vboxsf: allocated %p (path=%p name=%p)\n", vn, vn->path, vn->name);
-        status_t rv = g_cache.Insert(vn);
+    dprintf("creating new vnode at %p with path=%p (%s)\n", vn, path->String.utf8, path->String.utf8);
+    vn->map = map;
+    vn->path = path;
+    if (name)
+        vn->name = name;
+    else
+    {
+        const char* cname = strrchr((char*)path->String.utf8, '/');
+        if (!cname)
+            vn->name = path; // no slash, assume this *is* the filename
+        else
+            vn->name = make_shflstring(cname);
+    }
 
-        mutex_unlock(&g_vnodeCacheLock);
+    if (mutex_lock(&g_vnodeCacheLock) < B_OK)
+    {
+        free(vn);
+        return B_ERROR;
+    }
 
-        return rv;
+    vn->vnode = g_nextVnid++;
+    *p = vn;
+    dprintf("vboxsf: allocated %p (path=%p name=%p)\n", vn, vn->path, vn->name);
+    status_t rv = g_cache.Insert(vn);
+
+    mutex_unlock(&g_vnodeCacheLock);
+
+    return rv;
 }
 
+
 extern "C" status_t vboxsf_get_vnode(fs_volume* volume, ino_t id, fs_vnode* vnode,
-        int* _type, uint32* _flags, bool reenter) {
-        vboxsf_vnode* vn = g_cache.Lookup(id);
-        if (vn) {
-                vnode->private_node = vn;
-                return B_OK;
-        }
-        else {
-                return B_ERROR;
-        }
+    int* _type, uint32* _flags, bool reenter)
+{
+    vboxsf_vnode* vn = g_cache.Lookup(id);
+    if (vn)
+    {
+        vnode->private_node = vn;
+        return B_OK;
+    }
+    return B_ERROR;
 }
 
-extern "C" status_t vboxsf_put_vnode(fs_volume* volume, fs_vnode* vnode, bool reenter) {
-        g_cache.Remove((vboxsf_vnode*)vnode->private_node);
+
+extern "C" status_t vboxsf_put_vnode(fs_volume* volume, fs_vnode* vnode, bool reenter)
+{
+    g_cache.Remove((vboxsf_vnode*)vnode->private_node);
 }
+

trunk/src/VBox/Additions/haiku/VBoxMouse/VBoxMouse.cpp

@@ -63 +63 @@
 
 /* Export as global symbol with C linkage, RTDECL is necessary. */
-RTDECL(BInputServerDevice*)
+RTDECL(BInputServerDevice *)
 instantiate_input_device()
 {
@@ -69 +69 @@
 }
 
+
 VBoxMouse::VBoxMouse()
-        : BInputServerDevice(),
-        fDriverFD(-1),
-        fServiceThreadID(-1),
-        fExiting(false)
-{
-}
+     : BInputServerDevice(),
+       fDriverFD(-1),
+       fServiceThreadID(-1),
+       fExiting(false)
+{
+}
+
 
 VBoxMouse::~VBoxMouse()
 {
 }
+
 
 status_t VBoxMouse::InitCheck()
@@ -85 +88 @@
     int rc = VbglR3Init();
     if (!RT_SUCCESS(rc))
-                return ENXIO;
-
-        //// Start() will *not* Init() again
+        return ENXIO;
+
+    //// Start() will *not* Init() again
     //VbglR3Term();
 
-//              return B_DEVICE_NOT_FOUND;
-
-        input_device_ref device = { (char *)"VBoxMouse",
-                B_POINTING_DEVICE, (void*)this };
-        input_device_ref* deviceList[2] = { &device, NULL };
-        RegisterDevices(deviceList);
-
-        return B_OK;
-}
+//        return B_DEVICE_NOT_FOUND;
+
+    input_device_ref device = { (char *)"VBoxMouse",
+        B_POINTING_DEVICE, (void *)this };
+    input_device_ref *deviceList[2] = { &device, NULL };
+    RegisterDevices(deviceList);
+
+    return B_OK;
+}
+
 
 status_t VBoxMouse::SystemShuttingDown()
@@ -104 +108 @@
     VbglR3Term();
 
-        return B_OK;
-}
-
-status_t VBoxMouse::Start(const char* device, void* cookie)
-{
-        status_t err;
-        int rc;
+    return B_OK;
+}
+
+
+status_t VBoxMouse::Start(const char *device, void *cookie)
+{
+    status_t err;
+    int rc;
     uint32_t fFeatures = 0;
     Log(("VBoxMouse::%s()\n", __FUNCTION__));
@@ -116 +121 @@
     rc = VbglR3GetMouseStatus(&fFeatures, NULL, NULL);
     if (RT_SUCCESS(rc))
-        rc = VbglR3SetMouseStatus(  fFeatures
+        rc = VbglR3SetMouseStatus(fFeatures
                                   | VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
                                   | VMMDEV_MOUSE_NEW_PROTOCOL);
-    if (!RT_SUCCESS(rc)) {
-                LogRel(("VBoxMouse: Error switching guest mouse into absolute mode: %d\n", rc));
+    if (!RT_SUCCESS(rc))
+    {
+        LogRel(("VBoxMouse: Error switching guest mouse into absolute mode: %d\n", rc));
         return B_DEVICE_NOT_FOUND;
     }
 
-        err = fServiceThreadID = spawn_thread(_ServiceThreadNub,
-                        "VBoxMouse", B_NORMAL_PRIORITY, this);
-        if (err >= B_OK) {
-                resume_thread(fServiceThreadID);
-                return B_OK;
-        } else
+    err = fServiceThreadID = spawn_thread(_ServiceThreadNub,
+                                          "VBoxMouse", B_NORMAL_PRIORITY, this);
+    if (err >= B_OK)
+    {
+        resume_thread(fServiceThreadID);
+        return B_OK;
+    }
+    else
         LogRel(("VBoxMouse: Error starting service thread: 0x%08lx\n",
-                err));
-
-        // release the mouse
+                err));
+
+    // release the mouse
     rc = VbglR3GetMouseStatus(&fFeatures, NULL, NULL);
     if (RT_SUCCESS(rc))
-        rc = VbglR3SetMouseStatus(  fFeatures
+        rc = VbglR3SetMouseStatus(fFeatures
                                   & ~VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
                                   & ~VMMDEV_MOUSE_NEW_PROTOCOL);
 
-         return B_ERROR;
-}
-
-status_t VBoxMouse::Stop(const char* device, void* cookie)
-{
-        status_t status;
-        int rc;
+    return B_ERROR;
+}
+
+
+status_t VBoxMouse::Stop(const char *device, void *cookie)
+{
+    status_t status;
+    int rc;
     uint32_t fFeatures = 0;
     Log(("VBoxMouse::%s()\n", __FUNCTION__));
 
-        fExiting = true;
+    fExiting = true;
 
 
     rc = VbglR3GetMouseStatus(&fFeatures, NULL, NULL);
     if (RT_SUCCESS(rc))
-        rc = VbglR3SetMouseStatus(  fFeatures
+        rc = VbglR3SetMouseStatus(fFeatures
                                   & ~VMMDEV_MOUSE_GUEST_CAN_ABSOLUTE
                                   & ~VMMDEV_MOUSE_NEW_PROTOCOL);
 
 
-        close(fDriverFD);
-        fDriverFD = -1;
-        //XXX WTF ?
-        suspend_thread(fServiceThreadID);
-        resume_thread(fServiceThreadID);
-        wait_for_thread(fServiceThreadID, &status);
-        fServiceThreadID = -1;
-        fExiting = false;
-    return B_OK;
-}
-
-status_t VBoxMouse::Control(const char  *device,
-                                                void            *cookie,
-                                                uint32          code,
-                                                BMessage        *message)
-{
-        // respond to changes in the system
-        switch (code) {
-                case B_MOUSE_SPEED_CHANGED:
-                case B_CLICK_SPEED_CHANGED:
-                case B_MOUSE_ACCELERATION_CHANGED:
-                default:
-                        return BInputServerDevice::Control(device, cookie, code, message);
-        }
-        return B_OK;
-}
+    close(fDriverFD);
+    fDriverFD = -1;
+    //XXX WTF ?
+    suspend_thread(fServiceThreadID);
+    resume_thread(fServiceThreadID);
+    wait_for_thread(fServiceThreadID, &status);
+    fServiceThreadID = -1;
+    fExiting = false;
+    return B_OK;
+}
+
+
+status_t VBoxMouse::Control(const char *device, void *cookie, uint32 code, BMessage *message)
+{
+    // respond to changes in the system
+    switch (code)
+    {
+        case B_MOUSE_SPEED_CHANGED:
+        case B_CLICK_SPEED_CHANGED:
+        case B_MOUSE_ACCELERATION_CHANGED:
+        default:
+            return BInputServerDevice::Control(device, cookie, code, message);
+    }
+    return B_OK;
+}
+
 
 status_t VBoxMouse::_ServiceThreadNub(void *_this)
 {
-        VBoxMouse *service = (VBoxMouse *)_this;
-        return service->_ServiceThread();
-}
+    VBoxMouse *service = (VBoxMouse *)_this;
+    return service->_ServiceThread();
+}
+
 
 status_t VBoxMouse::_ServiceThread()
@@ -197 +207 @@
     Log(("VBoxMouse::%s()\n", __FUNCTION__));
 
-        fDriverFD = open(VBOXGUEST_DEVICE_NAME, O_RDWR);
-        if (fDriverFD < 0)
-                return ENXIO;
+    fDriverFD = open(VBOXGUEST_DEVICE_NAME, O_RDWR);
+    if (fDriverFD < 0)
+        return ENXIO;
 
     /* The thread waits for incoming messages from the host. */
     while (!fExiting)
     {
-            uint32_t cx, cy, fFeatures;
-        int rc;
-
-
-                fd_set readSet, writeSet, errorSet;
-                FD_ZERO(&readSet);
-                FD_ZERO(&writeSet);
-                FD_ZERO(&errorSet);
-                FD_SET(fDriverFD, &readSet);
-                if (fDriverFD < 0)
-                        break;
-                rc = select(fDriverFD + 1, &readSet, &writeSet, &errorSet, NULL);
-                if (rc < 0) {
-                        if (errno == EINTR || errno == EAGAIN)
-                                continue;
-                        break;
-                }
-
-            if (RT_SUCCESS(VbglR3GetMouseStatus(&fFeatures, &cx, &cy))
-            && (fFeatures & VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE))
-        {
-                float x = cx * 1.0 / 65535;
-                float y = cy * 1.0 / 65535;
-
-                _debugPrintf("VBoxMouse: at %d,%d %f,%f\n", cx, cy, x, y);
-
-                /* send absolute movement */
-
-                        bigtime_t now = system_time();
-                        BMessage* event = new BMessage(B_MOUSE_MOVED);
-                        event->AddInt64("when", now);
-                        event->AddFloat("x", x);
-                        event->AddFloat("y", y);
-                        event->AddFloat("be:tablet_x", x);
-                        event->AddFloat("be:tablet_y", y);
-                        //event->PrintToStream();
-                        EnqueueMessage(event);
-
-                //LogRelFlow(("processed host event rc = %d\n", rc));
-        }
-    }
-        return 0;
-}
-
-
+        uint32_t cx, cy, fFeatures;
+        int rc;
+
+
+        fd_set readSet, writeSet, errorSet;
+        FD_ZERO(&readSet);
+        FD_ZERO(&writeSet);
+        FD_ZERO(&errorSet);
+        FD_SET(fDriverFD, &readSet);
+        if (fDriverFD < 0)
+            break;
+        rc = select(fDriverFD + 1, &readSet, &writeSet, &errorSet, NULL);
+        if (rc < 0)
+        {
+            if (errno == EINTR || errno == EAGAIN)
+                continue;
+            break;
+        }
+
+        if (RT_SUCCESS(VbglR3GetMouseStatus(&fFeatures, &cx, &cy))
+            && (fFeatures & VMMDEV_MOUSE_HOST_WANTS_ABSOLUTE))
+        {
+            float x = cx * 1.0 / 65535;
+            float y = cy * 1.0 / 65535;
+
+            _debugPrintf("VBoxMouse: at %d,%d %f,%f\n", cx, cy, x, y);
+
+            /* send absolute movement */
+
+            bigtime_t now = system_time();
+            BMessage *event = new BMessage(B_MOUSE_MOVED);
+            event->AddInt64("when", now);
+            event->AddFloat("x", x);
+            event->AddFloat("y", y);
+            event->AddFloat("be:tablet_x", x);
+            event->AddFloat("be:tablet_y", y);
+            //event->PrintToStream();
+            EnqueueMessage(event);
+
+            //LogRelFlow(("processed host event rc = %d\n", rc));
+        }
+    }
+    return 0;
+}
+

trunk/src/VBox/Additions/haiku/VBoxMouse/VBoxMouse.h

@@ -50 +50 @@
 #include <InputServerDevice.h>
 
-extern "C" _EXPORT BInputServerDevice* instantiate_input_device();
+extern "C"
+_EXPORT BInputServerDevice* instantiate_input_device();
 
-class VBoxMouse : public BInputServerDevice {
-public:
-        VBoxMouse();
-        virtual ~VBoxMouse();
+class VBoxMouse : public BInputServerDevice
+{
+    public:
+        VBoxMouse();
+        virtual ~VBoxMouse();
 
-        virtual status_t                InitCheck();
-        virtual status_t                SystemShuttingDown();
+        virtual status_t                InitCheck();
+        virtual status_t                SystemShuttingDown();
 
-        virtual status_t                Start(const char* device, void* cookie);
-        virtual status_t                Stop(const char* device, void* cookie);
-        virtual status_t                Control(const char      *device,
-                                                                        void            *cookie,
-                                                                        uint32          code,
-                                                                        BMessage        *message);
+        virtual status_t                Start(const char *device, void *cookie);
+        virtual status_t                Stop(const char *device, void *cookie);
+        virtual status_t                Control(const char      *device,
+                                  void          *cookie,
+                                  uint32                code,
+                                  BMessage      *message);
 
-private:
+    private:
 
-static status_t _ServiceThreadNub(void *_this);
-        status_t        _ServiceThread();
+        static status_t _ServiceThreadNub(void *_this);
+        status_t        _ServiceThread();
 
-        int                     fDriverFD;
-        thread_id       fServiceThreadID;
-        bool            fExiting;
+        int                     fDriverFD;
+        thread_id       fServiceThreadID;
+        bool            fExiting;
 
 };
@@ -80 +82 @@
 
 #endif /* __VBOXMOUSE__H */
+

trunk/src/VBox/Additions/haiku/VBoxMouse/VBoxMouseFilter.cpp

@@ -64 +64 @@
 // TODO can this be merged with VBoxMouse?
 
-RTDECL(BInputServerFilter*)
+RTDECL(BInputServerFilter *)
 instantiate_input_filter()
 {
-        return new VBoxMouseFilter();
+    return new VBoxMouseFilter();
 }
 
 VBoxMouseFilter::VBoxMouseFilter()
-        : BInputServerFilter(),
-        fDriverFD(-1),
-        fServiceThreadID(-1),
-        fExiting(false),
-        fCurrentButtons(0)
+     : BInputServerFilter(),
+       fDriverFD(-1),
+       fServiceThreadID(-1),
+       fExiting(false),
+       fCurrentButtons(0)
 {
 }
@@ -83 +83 @@
 }
 
-filter_result VBoxMouseFilter::Filter(BMessage* message, BList* outList)
+filter_result VBoxMouseFilter::Filter(BMessage *message, BList *outList)
 {
-        switch(message->what) {
-                case B_MOUSE_UP:
-                case B_MOUSE_DOWN:
-                {
-                        printf("click|release\n");
-                        message->FindInt32("buttons", &fCurrentButtons);
-                }
-                case B_MOUSE_MOVED:
-                {
-                        printf("mouse moved\n");
-                        message->ReplaceInt32("buttons", fCurrentButtons);
-                }
-        }
+    switch (message->what)
+    {
+        case B_MOUSE_UP:
+        case B_MOUSE_DOWN:
+        {
+            printf("click|release\n");
+            message->FindInt32("buttons", &fCurrentButtons);
+        }
+        case B_MOUSE_MOVED:
+        {
+            printf("mouse moved\n");
+            message->ReplaceInt32("buttons", fCurrentButtons);
+        }
+    }
 
-        return B_DISPATCH_MESSAGE;
+    return B_DISPATCH_MESSAGE;
 }

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.cpp

@@ -74 +74 @@
 #define LogRelFlowFunc(x) printf x
 
+
 VBoxClipboardService::VBoxClipboardService()
-        : BHandler("VBoxClipboardService"),
-        fClientId(-1),
-        fServiceThreadID(-1),
-        fExiting(false)
-{
-}
+     : BHandler("VBoxClipboardService"),
+       fClientId(-1),
+       fServiceThreadID(-1),
+       fExiting(false)
+{
+}
+
 
 VBoxClipboardService::~VBoxClipboardService()
@@ -86 +88 @@
 }
 
+
 status_t VBoxClipboardService::Connect()
 {
-        status_t err;
+    status_t err;
     printf("VBoxClipboardService::%s()\n", __FUNCTION__);
 
     int rc = VbglR3ClipboardConnect(&fClientId);
-    if (RT_SUCCESS (rc)) {
-                err = fServiceThreadID = spawn_thread(_ServiceThreadNub,
-                        "VBoxClipboardService", B_NORMAL_PRIORITY, this);
-
-                if (err >= B_OK) {
-                        resume_thread(fServiceThreadID);
-
-                        err = be_clipboard->StartWatching(BMessenger(this));
-                        printf("be_clipboard->StartWatching: %ld\n", err);
-                        if (err == B_OK)
-                                return B_OK;
-                        else
-                        LogRel(("VBoxClipboardService: Error watching the system clipboard: %ld\n", err));
-                } else
-                LogRel(("VBoxClipboardService: Error starting service thread: %ld\n", err));
-
-                //rc = RTErrConvertFromErrno(err);
+    if (RT_SUCCESS(rc))
+    {
+        err = fServiceThreadID = spawn_thread(_ServiceThreadNub,
+                                              "VBoxClipboardService", B_NORMAL_PRIORITY, this);
+
+        if (err >= B_OK)
+        {
+            resume_thread(fServiceThreadID);
+
+            err = be_clipboard->StartWatching(BMessenger(this));
+            printf("be_clipboard->StartWatching: %ld\n", err);
+            if (err == B_OK)
+                return B_OK;
+            else
+                LogRel(("VBoxClipboardService: Error watching the system clipboard: %ld\n", err));
+        }
+        else
+            LogRel(("VBoxClipboardService: Error starting service thread: %ld\n", err));
+
+        //rc = RTErrConvertFromErrno(err);
         VbglR3ClipboardDisconnect(fClientId);
-        } else
+    }
+    else
         LogRel(("VBoxClipboardService: Error starting service thread: %d\n", rc));
-         return B_ERROR;
-}
+    return B_ERROR;
+}
+
 
 status_t VBoxClipboardService::Disconnect()
 {
-        status_t status;
-
-        be_clipboard->StopWatching(BMessenger(this));
-
-        fExiting = true;
+    status_t status;
+
+    be_clipboard->StopWatching(BMessenger(this));
+
+    fExiting = true;
 
     VbglR3ClipboardDisconnect(fClientId);
 
-        wait_for_thread(fServiceThreadID, &status);
+    wait_for_thread(fServiceThreadID, &status);
     return B_OK;
 }
 
-void VBoxClipboardService::MessageReceived(BMessage* message)
-{
-        uint32_t formats = 0;
-        message->PrintToStream();
-        switch (message->what) {
-                case VBOX_GUEST_CLIPBOARD_HOST_MSG_FORMATS:
-                {
-                        int rc;
-                        uint32_t cb;
-                        void *pv;
-                        bool commit = false;
-
-                        if (message->FindInt32("Formats", (int32 *)&formats) != B_OK)
-                                break;
-
-                        if (!formats)
-                                break;
-                        if (!be_clipboard->Lock())
-                                break;
-
-                        be_clipboard->Clear();
-                        BMessage *clip = be_clipboard->Data();
-                        if (!clip) {
-                                be_clipboard->Unlock();
-                                break;
-                        }
-
-                        if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT) {
-                                pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &cb);
-                                if (pv) {
-                                        char *text;
-                                        rc = RTUtf16ToUtf8((PCRTUTF16)pv, &text);
+
+void VBoxClipboardService::MessageReceived(BMessage *message)
+{
+    uint32_t formats = 0;
+    message->PrintToStream();
+    switch (message->what)
+    {
+        case VBOX_GUEST_CLIPBOARD_HOST_MSG_FORMATS:
+        {
+            int rc;
+            uint32_t cb;
+            void *pv;
+            bool commit = false;
+
+            if (message->FindInt32("Formats", (int32 *)&formats) != B_OK)
+                break;
+
+            if (!formats)
+                break;
+            if (!be_clipboard->Lock())
+                break;
+
+            be_clipboard->Clear();
+            BMessage *clip = be_clipboard->Data();
+            if (!clip)
+            {
+                be_clipboard->Unlock();
+                break;
+            }
+
+            if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+            {
+                pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, &cb);
+                if (pv)
+                {
+                    char *text;
+                    rc = RTUtf16ToUtf8((PCRTUTF16)pv, &text);
                     if (RT_SUCCESS(rc))
                     {
-                        BString str(text);
-                        // @todo use vboxClipboardUtf16WinToLin()
-                        // convert Windows CRLF to LF
-                        str.ReplaceAll("\r\n", "\n");
-                        // don't include the \0
-                                        clip->AddData("text/plain", B_MIME_TYPE, str.String(), str.Length());
-                                        RTStrFree(text);
-                                        commit = true;
+                        BString str(text);
+                        // @todo use vboxClipboardUtf16WinToLin()
+                        // convert Windows CRLF to LF
+                        str.ReplaceAll("\r\n", "\n");
+                        // don't include the \0
+                        clip->AddData("text/plain", B_MIME_TYPE, str.String(), str.Length());
+                        RTStrFree(text);
+                        commit = true;
                     }
-                                        free(pv);
-                                }
-                        }
-
-                        if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP) {
-                                pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &cb);
-                                if (pv) {
-                                        void *pBmp;
-                                        size_t cbBmp;
-                                        rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmp);
+                    free(pv);
+                }
+            }
+
+            if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+            {
+                pv = _VBoxReadHostClipboard(VBOX_SHARED_CLIPBOARD_FMT_BITMAP, &cb);
+                if (pv)
+                {
+                    void *pBmp;
+                    size_t cbBmp;
+                    rc = vboxClipboardDibToBmp(pv, cb, &pBmp, &cbBmp);
                     if (RT_SUCCESS(rc))
                     {
-                        BMemoryIO mio(pBmp, cbBmp);
-                        BBitmap *bitmap = BTranslationUtils::GetBitmap(&mio);
-                        if (bitmap)
-                        {
-                                BMessage bitmapArchive;
-                                if (bitmap->IsValid() &&
-                                        bitmap->Archive(&bitmapArchive) == B_OK &&
-                                        clip->AddMessage("image/bitmap", &bitmapArchive) == B_OK)
-                                {
-                                                        commit = true;
-                                }
-                                                delete bitmap;
-                        }
-                        RTMemFree(pBmp);
+                        BMemoryIO mio(pBmp, cbBmp);
+                        BBitmap *bitmap = BTranslationUtils::GetBitmap(&mio);
+                        if (bitmap)
+                        {
+                            BMessage bitmapArchive;
+                            if (bitmap->IsValid() &&
+                                bitmap->Archive(&bitmapArchive) == B_OK &&
+                                clip->AddMessage("image/bitmap", &bitmapArchive) == B_OK)
+                            {
+                                commit = true;
+                            }
+                            delete bitmap;
+                        }
+                        RTMemFree(pBmp);
                     }
-                                        free(pv);
-                                }
-                        }
-
-                        /* make sure we don't bounce this data back to the host,
-                         * it's impolite.
-                         * It can also be used as a hint to applications probably. */
-                        clip->AddBool("FromVirtualBoxHost", true);
-
-                        if (commit)
-                                be_clipboard->Commit();
-                        be_clipboard->Unlock();
-                        break;
-                }
-
-                case VBOX_GUEST_CLIPBOARD_HOST_MSG_READ_DATA:
-                {
-                        int rc;
-
-                        if (message->FindInt32("Formats", (int32 *)&formats) != B_OK)
-                                break;
-
-                        if (!formats)
-                                break;
-                        if (!be_clipboard->Lock())
-                                break;
-
-                        BMessage *clip = be_clipboard->Data();
-                        if (!clip) {
-                                be_clipboard->Unlock();
-                                break;
-                        }
-                        clip->PrintToStream();
-
-                        if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT) {
-                                const char *text;
-                                int32 textLen;
-                                if (clip->FindData("text/plain", B_MIME_TYPE, (const void **)&text, &textLen) == B_OK) {
-                        // usually doesn't include the \0 so be safe
-                                        BString str(text, textLen);
-                                        // convert from LF to Windows CRLF
-                                        str.ReplaceAll("\n", "\r\n");
+                    free(pv);
+                }
+            }
+
+            /* make sure we don't bounce this data back to the host,
+             * it's impolite.
+             * It can also be used as a hint to applications probably. */
+            clip->AddBool("FromVirtualBoxHost", true);
+
+            if (commit)
+                be_clipboard->Commit();
+            be_clipboard->Unlock();
+            break;
+        }
+
+        case VBOX_GUEST_CLIPBOARD_HOST_MSG_READ_DATA:
+        {
+            int rc;
+
+            if (message->FindInt32("Formats", (int32 *)&formats) != B_OK)
+                break;
+
+            if (!formats)
+                break;
+            if (!be_clipboard->Lock())
+                break;
+
+            BMessage *clip = be_clipboard->Data();
+            if (!clip)
+            {
+                be_clipboard->Unlock();
+                break;
+            }
+            clip->PrintToStream();
+
+            if (formats & VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT)
+            {
+                const char *text;
+                int32 textLen;
+                if (clip->FindData("text/plain", B_MIME_TYPE, (const void **)&text, &textLen) == B_OK)
+                {
+                    // usually doesn't include the \0 so be safe
+                    BString str(text, textLen);
+                    // convert from LF to Windows CRLF
+                    str.ReplaceAll("\n", "\r\n");
                     PRTUTF16 pwsz;
                     rc = RTStrToUtf16(str.String(), &pwsz);
@@ -247 +265 @@
                         uint32_t cb = (RTUtf16Len(pwsz) + 1) * sizeof(RTUTF16);
 
-                                        rc = VbglR3ClipboardWriteData(fClientId,
-                                                VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, pwsz, cb);
-                                                //printf("VbglR3ClipboardWriteData: %d\n", rc);
-
-                                        RTUtf16Free(pwsz);
+                        rc = VbglR3ClipboardWriteData(fClientId,
+                                                      VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT, pwsz, cb);
+                        //printf("VbglR3ClipboardWriteData: %d\n", rc);
+
+                        RTUtf16Free(pwsz);
                     }
-                                }
-                        }
-                        else if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
-                        {
-                                BMessage archivedBitmap;
-                                if (clip->FindMessage("image/bitmap", &archivedBitmap) == B_OK ||
-                                        clip->FindMessage("image/x-be-bitmap", &archivedBitmap) == B_OK) {
-                                        BBitmap *bitmap = new(std::nothrow) BBitmap(&archivedBitmap);
-                                        if (bitmap)
-                                        {
-                                                // Don't delete bitmap, BBitmapStream will.
-                                                BBitmapStream stream(bitmap);
-                                                BTranslatorRoster *roster = BTranslatorRoster::Default();
-                                                if (roster && bitmap->IsValid())
-                                                {
-                                                        BMallocIO bmpStream;
-                                                        if (roster->Translate(&stream, NULL, NULL, &bmpStream, B_BMP_FORMAT) == B_OK)
-                                                        {
-                                                                const void *pDib;
-                                                                size_t cbDibSize;
-                                                                /* Strip out the BM header */
-                                                                rc = vboxClipboardBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
-                                                                if (RT_SUCCESS(rc))
-                                                                {
-                                                            rc = VbglR3ClipboardWriteData(fClientId,
-                                                                    VBOX_SHARED_CLIPBOARD_FMT_BITMAP, (void *)pDib, cbDibSize);
-                                                                }
-                                                        }
-                                                }
-                                        }
-                                }
-                        }
-
-                        be_clipboard->Unlock();
-                        break;
-                }
-
-                case B_CLIPBOARD_CHANGED:
-                {
-                        printf("B_CLIPBOARD_CHANGED\n");
-                        const void *data;
-                        int32 dataLen;
-                        if (!be_clipboard->Lock())
-                                break;
-
-                        BMessage *clip = be_clipboard->Data();
-                        if (!clip) {
-                                be_clipboard->Unlock();
-                                break;
-                        }
-
-                        bool fromVBox;
-                        if (clip->FindBool("FromVirtualBoxHost", &fromVBox) == B_OK && fromVBox) {
-                                // It already comes from the host, discard.
-                                be_clipboard->Unlock();
-                                break;
-                        }
-
-                        if (clip->FindData("text/plain", B_MIME_TYPE, &data, &dataLen) == B_OK)
-                                formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
-                        if (clip->HasMessage("image/bitmap") || clip->HasMessage("image/x-be-bitmap"))
-                                formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
-
-                        be_clipboard->Unlock();
-
-                    VbglR3ClipboardReportFormats(fClientId, formats);
-                        break;
-                }
-
-                case B_QUIT_REQUESTED:
-                        fExiting = true;
-                        break;
-
-                default:
-                        BHandler::MessageReceived(message);
-        }
-}
+                }
+            }
+            else if (formats & VBOX_SHARED_CLIPBOARD_FMT_BITMAP)
+            {
+                BMessage archivedBitmap;
+                if (clip->FindMessage("image/bitmap", &archivedBitmap) == B_OK ||
+                    clip->FindMessage("image/x-be-bitmap", &archivedBitmap) == B_OK)
+                {
+                    BBitmap *bitmap = new(std::nothrow) BBitmap(&archivedBitmap);
+                    if (bitmap)
+                    {
+                        // Don't delete bitmap, BBitmapStream will.
+                        BBitmapStream stream(bitmap);
+                        BTranslatorRoster *roster = BTranslatorRoster::Default();
+                        if (roster && bitmap->IsValid())
+                        {
+                            BMallocIO bmpStream;
+                            if (roster->Translate(&stream, NULL, NULL, &bmpStream, B_BMP_FORMAT) == B_OK)
+                            {
+                                const void *pDib;
+                                size_t cbDibSize;
+                                /* Strip out the BM header */
+                                rc = vboxClipboardBmpGetDib(bmpStream.Buffer(), bmpStream.BufferLength(), &pDib, &cbDibSize);
+                                if (RT_SUCCESS(rc))
+                                {
+                                    rc = VbglR3ClipboardWriteData(fClientId,
+                                                                  VBOX_SHARED_CLIPBOARD_FMT_BITMAP, (void *)pDib, cbDibSize);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            be_clipboard->Unlock();
+            break;
+        }
+
+        case B_CLIPBOARD_CHANGED:
+        {
+            printf("B_CLIPBOARD_CHANGED\n");
+            const void *data;
+            int32 dataLen;
+            if (!be_clipboard->Lock())
+                break;
+
+            BMessage *clip = be_clipboard->Data();
+            if (!clip)
+            {
+                be_clipboard->Unlock();
+                break;
+            }
+
+            bool fromVBox;
+            if (clip->FindBool("FromVirtualBoxHost", &fromVBox) == B_OK && fromVBox)
+            {
+                // It already comes from the host, discard.
+                be_clipboard->Unlock();
+                break;
+            }
+
+            if (clip->FindData("text/plain", B_MIME_TYPE, &data, &dataLen) == B_OK)
+                formats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT;
+            if (clip->HasMessage("image/bitmap") || clip->HasMessage("image/x-be-bitmap"))
+                formats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP;
+
+            be_clipboard->Unlock();
+
+            VbglR3ClipboardReportFormats(fClientId, formats);
+            break;
+        }
+
+        case B_QUIT_REQUESTED:
+            fExiting = true;
+            break;
+
+        default:
+            BHandler::MessageReceived(message);
+    }
+}
+
 
 status_t VBoxClipboardService::_ServiceThreadNub(void *_this)
 {
-        VBoxClipboardService *service = (VBoxClipboardService *)_this;
-        return service->_ServiceThread();
-}
+    VBoxClipboardService *service = (VBoxClipboardService *)_this;
+    return service->_ServiceThread();
+}
+
 
 status_t VBoxClipboardService::_ServiceThread()
@@ -347 +370 @@
         uint32_t u32Formats;
         int rc = VbglR3ClipboardGetHostMsg(fClientId, &u32Msg, &u32Formats);
-        if (RT_SUCCESS(rc)) {
-            switch (u32Msg) {
+        if (RT_SUCCESS(rc))
+        {
+            switch (u32Msg)
+            {
                 case VBOX_SHARED_CLIPBOARD_HOST_MSG_FORMATS:
                 {
@@ -374 +399 @@
                     /* The host is terminating. */
                     LogRelFlowFunc(("VBOX_SHARED_CLIPBOARD_HOST_MSG_QUIT\n"));
-                                        fExiting = true;
+                    fExiting = true;
                     return VERR_INTERRUPTED;
                 }
@@ -381 +406 @@
                     Log(("VBoxClipboardService::%s: Unsupported message from host! Message = %u\n", __FUNCTION__, u32Msg));
             }
-        } else
-                fExiting = true;
+        }
+        else
+            fExiting = true;
 
         LogRelFlow(("processed host event rc = %d\n", rc));
 
         if (fExiting)
-                break;
+            break;
     }
-        return 0;
-}
-
-
-void *VBoxClipboardService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
-{
-        uint32_t cb = 1024;
-        void *pv;
-        int rc;
-
-        pv = malloc(cb);
-        if (pv == NULL)
-                return NULL;
-
-        rc = VbglR3ClipboardReadData(fClientId, format, pv, cb, pcb);
+    return 0;
+}
+
+
+void* VBoxClipboardService::_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb)
+{
+    uint32_t cb = 1024;
+    void *pv;
+    int rc;
+
+    pv = malloc(cb);
+    if (pv == NULL)
+        return NULL;
+
+    rc = VbglR3ClipboardReadData(fClientId, format, pv, cb, pcb);
     if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
         return pv;
     if (rc == VINF_BUFFER_OVERFLOW)
     {
-            free(pv);
-            cb = *pcb;
-        pv = malloc(cb);
-                if (pv == NULL)
-                        return NULL;
-
-                rc = VbglR3ClipboardReadData(fClientId, format, pv, cb, pcb);
-        if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
-                return pv;
-
-            free(pv);
+        free(pv);
+        cb = *pcb;
+        pv = malloc(cb);
+        if (pv == NULL)
+            return NULL;
+
+        rc = VbglR3ClipboardReadData(fClientId, format, pv, cb, pcb);
+        if (RT_SUCCESS(rc) && (rc != VINF_BUFFER_OVERFLOW))
+            return pv;
+
+        free(pv);
     }
     return NULL;

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxClipboard.h

@@ -50 +50 @@
 #include <Handler.h>
 
-class VBoxClipboardService : public BHandler {
-public:
-        VBoxClipboardService();
-        virtual ~VBoxClipboardService();
+class VBoxClipboardService : public BHandler
+{
+    public:
+        VBoxClipboardService();
+        virtual ~VBoxClipboardService();
 
-        virtual status_t        Connect();
-        virtual status_t        Disconnect();
+        virtual status_t        Connect();
+        virtual status_t        Disconnect();
 
-        virtual void            MessageReceived(BMessage* message);
+        virtual void            MessageReceived(BMessage *message);
 
-private:
+    private:
 
-static status_t _ServiceThreadNub(void *_this);
-        status_t        _ServiceThread();
+        static status_t _ServiceThreadNub(void *_this);
+        status_t        _ServiceThread();
 
-        void            *_VBoxReadHostClipboard(uint32_t format, uint32_t *pcb);
+        void* _VBoxReadHostClipboard(uint32_t format, uint32_t *pcb);
 
-        uint32_t        fClientId;
-        thread_id       fServiceThreadID;
-        bool            fExiting;
+        uint32_t        fClientId;
+        thread_id       fServiceThreadID;
+        bool            fExiting;
 
 };

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxDisplay.cpp

@@ -71 +71 @@
 
 VBoxDisplayService::VBoxDisplayService()
-        : BHandler("VBoxDisplayService"),
-        fClientId(-1),
-        fServiceThreadID(-1),
-        fExiting(false),
-        fScreen(B_MAIN_SCREEN_ID)
+     : BHandler("VBoxDisplayService"),
+       fClientId(-1),
+       fServiceThreadID(-1),
+       fExiting(false),
+       fScreen(B_MAIN_SCREEN_ID)
 {
 }
+
 
 VBoxDisplayService::~VBoxDisplayService()
@@ -83 +84 @@
 }
 
+
 void VBoxDisplayService::Start()
 {
-        status_t err;
-        err = fServiceThreadID = spawn_thread(_ServiceThreadNub,
-                "VBoxDisplayService", B_NORMAL_PRIORITY, this);
+    status_t err;
+    err = fServiceThreadID = spawn_thread(_ServiceThreadNub,
+                                          "VBoxDisplayService", B_NORMAL_PRIORITY, this);
 
-        if (err >= B_OK) {
-                resume_thread(fServiceThreadID);
-        } else
-                LogRel(("VBoxDisplayService: Error starting service thread: %s\n", strerror(err)));
+    if (err >= B_OK)
+        resume_thread(fServiceThreadID);
+    else
+        LogRel(("VBoxDisplayService: Error starting service thread: %s\n", strerror(err)));
 
 }
 
-void VBoxDisplayService::MessageReceived(BMessage* message)
+
+void VBoxDisplayService::MessageReceived(BMessage *message)
 {
-        if (message->what == B_QUIT_REQUESTED)
-                fExiting = true;
-        else
-                BHandler::MessageReceived(message);
+    if (message->what == B_QUIT_REQUESTED)
+        fExiting = true;
+    else
+        BHandler::MessageReceived(message);
 }
+
 
 status_t VBoxDisplayService::_ServiceThreadNub(void *_this)
 {
-        VBoxDisplayService *service = (VBoxDisplayService *)_this;
-        return service->_ServiceThread();
+    VBoxDisplayService *service = (VBoxDisplayService *)_this;
+    return service->_ServiceThread();
 }
+
 
 status_t VBoxDisplayService::_ServiceThread()
@@ -115 +120 @@
 
     VbglR3CtlFilterMask(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, 0);
-        VbglR3SetGuestCaps(VMMDEV_GUEST_SUPPORTS_GRAPHICS, 0);
+    VbglR3SetGuestCaps(VMMDEV_GUEST_SUPPORTS_GRAPHICS, 0);
 
-    for (;;) {
-                uint32_t events;
+    for (;;)
+    {
+        uint32_t events;
 
-                int rc = VbglR3WaitEvent(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, 5000, &events);
-                if (rc == -6) // timed out?
-                        continue;
+        int rc = VbglR3WaitEvent(VMMDEV_EVENT_DISPLAY_CHANGE_REQUEST, 5000, &events);
+        if (rc == -6) // timed out?
+            continue;
 
-                if (RT_SUCCESS(rc)) {
-                        uint32_t cx, cy, cBits, iDisplay;
+        if (RT_SUCCESS(rc))
+        {
+            uint32_t cx, cy, cBits, iDisplay;
             int rc2 = VbglR3GetDisplayChangeRequest(&cx, &cy, &cBits, &iDisplay, true);
-                        printf("rc2=%d screen %d size changed (%d, %d, %d)\n", rc2, iDisplay, cx, cy, cBits);
+            printf("rc2=%d screen %d size changed (%d, %d, %d)\n", rc2, iDisplay, cx, cy, cBits);
 
-                        if (RT_SUCCESS(rc2)) {
-                                display_mode mode;
-                                fScreen.GetMode(&mode);
-                                if (cBits == 0) {
-                                        cBits = get_depth_for_color_space(mode.space);
-                                }
-                                mode.timing.h_display = cx;
-                                mode.timing.v_display = cy;
-                                mode.space = get_color_space_for_depth(cBits);
-                                mode.virtual_width = cx;
-                                mode.virtual_height = cy;
+            if (RT_SUCCESS(rc2))
+            {
+                display_mode mode;
+                fScreen.GetMode(&mode);
+                if (cBits == 0)
+                {
+                    cBits = get_depth_for_color_space(mode.space);
+                }
+                mode.timing.h_display = cx;
+                mode.timing.v_display = cy;
+                mode.space = get_color_space_for_depth(cBits);
+                mode.virtual_width = cx;
+                mode.virtual_height = cy;
 
-                                /*= {
-                                        {0, cx, 0, 0, cBits * cx / 8, cy, 0, 0, cBits * cy / 8, 0},
-                                        get_color_space_for_depth(cBits),
-                                        cx, cy, 0, 0, 0
-                                };*/
+                /*= {
+                    {0, cx, 0, 0, cBits * cx / 8, cy, 0, 0, cBits * cy / 8, 0},
+                    get_color_space_for_depth(cBits),
+                    cx, cy, 0, 0, 0
+                };*/
 
-                                fScreen.SetMode(&mode, false);
-                        }
+                fScreen.SetMode(&mode, false);
+            }
         }
         else
-                fExiting = true;
+            fExiting = true;
 
         LogRelFlow(("processed host event rc = %d\n", rc));
 
         if (fExiting)
-                break;
+            break;
     }
-        return 0;
+    return 0;
 }
+

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxDisplay.h

@@ -51 +51 @@
 #include <Screen.h>
 
-class VBoxDisplayService : public BHandler {
-public:
-        VBoxDisplayService();
-        virtual ~VBoxDisplayService();
+class VBoxDisplayService : public BHandler
+{
+    public:
+        VBoxDisplayService();
+        virtual ~VBoxDisplayService();
 
-        void            Start();
+        void                Start();
 
-        virtual void            MessageReceived(BMessage* message);
+        virtual    void     MessageReceived(BMessage *message);
 
-private:
+    private:
 
-static status_t _ServiceThreadNub(void *_this);
-        status_t        _ServiceThread();
+        static status_t     _ServiceThreadNub(void *_this);
+        status_t            _ServiceThread();
 
-        uint32_t        fClientId;
-        thread_id       fServiceThreadID;
-volatile bool   fExiting;
-        BScreen         fScreen;
+        uint32_t            fClientId;
+        thread_id           fServiceThreadID;
+        volatile bool       fExiting;
+        BScreen             fScreen;
 };
 
+#endif /* __VBOXSERVICESHAREDCLIPLBOARD__H */
 
-#endif /* __VBOXSERVICESHAREDCLIPLBOARD__H */

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestApplication.cpp

@@ -60 +60 @@
 
 VBoxGuestApplication::VBoxGuestApplication()
-        : BApplication(VBOX_GUEST_APP_SIG)
+     : BApplication(VBOX_GUEST_APP_SIG)
 {
-        PRINT(("%s()\n", __FUNCTION__));
+    PRINT(("%s()\n", __FUNCTION__));
 }
+
 
 VBoxGuestApplication::~VBoxGuestApplication()
 {
-        PRINT(("%s()\n", __FUNCTION__));
+    PRINT(("%s()\n", __FUNCTION__));
 }
+
 
 void VBoxGuestApplication::ReadyToRun()
 {
-        status_t err;
+    status_t err;
 
-        err = VBoxGuestDeskbarView::AddToDeskbar();
-        PRINT(("%s: VBoxGuestDeskbarView::AddToDeskbar: 0x%08lx\n", __FUNCTION__, err));
+    err = VBoxGuestDeskbarView::AddToDeskbar();
+    PRINT(("%s: VBoxGuestDeskbarView::AddToDeskbar: 0x%08lx\n", __FUNCTION__, err));
 
-        exit(0);
+    exit(0);
 }
+
 
 int main(int argc, const char **argv)
 {
-        new VBoxGuestApplication();
-        be_app->Run();
-        delete be_app;
+    new VBoxGuestApplication();
+    be_app->Run();
+    delete be_app;
 
 /*    int rc = RTR3Init();
@@ -96 +99 @@
     if (RT_SUCCESS(rc))
     {
-            Log(("VBoxGuestApp: Init successful\n"));
+        Log(("VBoxGuestApp: Init successful\n"));
 
-                new VBoxGuestApplication(gVBoxDriverFD);
-                be_app->Run();
-                delete be_app;
+        new VBoxGuestApplication(gVBoxDriverFD);
+        be_app->Run();
+        delete be_app;
 
     }
 
-        if (RT_FAILURE(rc))
+    if (RT_FAILURE(rc))
     {
         LogRel(("VBoxGuestApp: Error while starting, rc=%Rrc\n", rc));
@@ -110 +113 @@
     LogRel(("VBoxGuestApp: Ended\n"));
 
-        vboxCloseBaseDriver();
+    vboxCloseBaseDriver();
 
     VbglR3Term();*/
 
-        return 0;
+    return 0;
 }
+

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.cpp

@@ -69 +69 @@
 our_image(image_info& image)
 {
-        /** @todo r=ramshankar: find a way to do this without annoying the compiler, probably uintptr_t? */
-        int32 cookie = 0;
-        while (get_next_image_info(B_CURRENT_TEAM, &cookie, &image) == B_OK) {
-                if ((char *)our_image >= (char *)image.text
-                        && (char *)our_image <= (char *)image.text + image.text_size)
-                        return B_OK;
-        }
-
-        return B_ERROR;
+    /** @todo r=ramshankar: find a way to do this without annoying the compiler, probably uintptr_t? */
+    int32 cookie = 0;
+    while (get_next_image_info(B_CURRENT_TEAM, &cookie, &image) == B_OK)
+    {
+        if ((char *)our_image >= (char *)image.text
+            && (char *)our_image <= (char *)image.text + image.text_size)
+            return B_OK;
+    }
+
+    return B_ERROR;
 }
 
 
 VBoxGuestDeskbarView::VBoxGuestDeskbarView()
-        : BView(BRect(0, 0, 15, 15), VIEWNAME, B_FOLLOW_NONE,
-                B_WILL_DRAW | B_NAVIGABLE),
-        fIcon(NULL), fClipboardService(NULL), fDisplayService(NULL)
-{
-        PRINT(("%s()\n", __FUNCTION__));
-        _Init();
-}
+     : BView(BRect(0, 0, 15, 15), VIEWNAME, B_FOLLOW_NONE,
+             B_WILL_DRAW | B_NAVIGABLE),
+       fIcon(NULL), fClipboardService(NULL), fDisplayService(NULL)
+{
+    PRINT(("%s()\n", __FUNCTION__));
+    _Init();
+}
+
 
 VBoxGuestDeskbarView::VBoxGuestDeskbarView(BMessage *archive)
-        : BView(archive),
-        fIcon(NULL)
-{
-        PRINT(("%s()\n", __FUNCTION__));
-        archive->PrintToStream();
-
-        _Init(archive);
-}
+     : BView(archive),
+       fIcon(NULL)
+{
+    PRINT(("%s()\n", __FUNCTION__));
+    archive->PrintToStream();
+
+    _Init(archive);
+}
+
 
 VBoxGuestDeskbarView::~VBoxGuestDeskbarView()
 {
-        PRINT(("%s()\n", __FUNCTION__));
-        delete fIcon;
-        if (fClipboardService) {
-                fClipboardService->Disconnect();
-                delete fClipboardService;
-        }
-        VbglR3Term();
-}
-
-BArchivable *VBoxGuestDeskbarView::Instantiate(BMessage *data)
-{
-        PRINT(("%s()\n", __FUNCTION__));
-        if (!validate_instantiation(data, VIEWNAME))
-                return NULL;
-
-        return new VBoxGuestDeskbarView(data);
-}
+    PRINT(("%s()\n", __FUNCTION__));
+    delete fIcon;
+    if (fClipboardService)
+    {
+        fClipboardService->Disconnect();
+        delete fClipboardService;
+    }
+    VbglR3Term();
+}
+
+
+BArchivable* VBoxGuestDeskbarView::Instantiate(BMessage *data)
+{
+    PRINT(("%s()\n", __FUNCTION__));
+    if (!validate_instantiation(data, VIEWNAME))
+        return NULL;
+
+    return new VBoxGuestDeskbarView(data);
+}
+
 
 status_t VBoxGuestDeskbarView::Archive(BMessage *data, bool deep) const
 {
-        status_t err;
-        PRINT(("%s()\n", __FUNCTION__));
-
-        err = BView::Archive(data, false);
-        if (err < B_OK)
-                return err;
-        data->AddString("add_on", VBOX_GUEST_APP_SIG);
-        data->AddString("class", "VBoxGuestDeskbarView");
-        return B_OK;
-}
+    status_t err;
+    PRINT(("%s()\n", __FUNCTION__));
+
+    err = BView::Archive(data, false);
+    if (err < B_OK)
+        return err;
+    data->AddString("add_on", VBOX_GUEST_APP_SIG);
+    data->AddString("class", "VBoxGuestDeskbarView");
+    return B_OK;
+}
+
 
 void VBoxGuestDeskbarView::Draw(BRect rect)
 {
-        SetDrawingMode(B_OP_ALPHA);
-        DrawBitmap(fIcon);
-}
+    SetDrawingMode(B_OP_ALPHA);
+    DrawBitmap(fIcon);
+}
+
 
 void VBoxGuestDeskbarView::AttachedToWindow()
 {
-        BView::AttachedToWindow();
-        if (Parent()) {
-                SetViewColor(Parent()->ViewColor());
-                SetLowColor(Parent()->LowColor());
-        }
-
-        if (fClipboardService) { // don't repeatedly crash deskbar if vboxdev not loaded
-                Looper()->AddHandler(fClipboardService);
-                fClipboardService->Connect();
-        }
-
-        if (fDisplayService) {
-                fDisplayService->Start();
-        }
-}
+    BView::AttachedToWindow();
+    if (Parent())
+    {
+        SetViewColor(Parent()->ViewColor());
+        SetLowColor(Parent()->LowColor());
+    }
+
+    if (fClipboardService) // don't repeatedly crash deskbar if vboxdev not loaded
+    {
+        Looper()->AddHandler(fClipboardService);
+        fClipboardService->Connect();
+    }
+
+    if (fDisplayService)
+    {
+        fDisplayService->Start();
+    }
+}
+
 
 void VBoxGuestDeskbarView::DetachedFromWindow()
 {
-        BMessage message(B_QUIT_REQUESTED);
-        fClipboardService->MessageReceived(&message);
-        fDisplayService->MessageReceived(&message);
-}
+    BMessage message(B_QUIT_REQUESTED);
+    fClipboardService->MessageReceived(&message);
+    fDisplayService->MessageReceived(&message);
+}
+
 
 void VBoxGuestDeskbarView::MouseDown(BPoint point)
 {
-        printf("MouseDown\n");
-        int32 buttons = B_PRIMARY_MOUSE_BUTTON;
-        if (Looper() != NULL && Looper()->CurrentMessage() != NULL)
-                Looper()->CurrentMessage()->FindInt32("buttons", &buttons);
-
-        BPoint where = ConvertToScreen(point);
-
-        if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0) {
-                BPopUpMenu* menu = new BPopUpMenu(B_EMPTY_STRING, false, false);
-                menu->SetAsyncAutoDestruct(true);
-                menu->SetFont(be_plain_font);
-
-                menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED)));
-                menu->SetTargetForItems(this);
-
-                menu->Go(where, true, true, true);
-        }
-}
-
-void VBoxGuestDeskbarView::MessageReceived(BMessage* message)
-{
-        if (message->what == B_QUIT_REQUESTED)
-                RemoveFromDeskbar();
-        else
-                BHandler::MessageReceived(message);
-}
+    printf("MouseDown\n");
+    int32 buttons = B_PRIMARY_MOUSE_BUTTON;
+    if (Looper() != NULL && Looper()->CurrentMessage() != NULL)
+        Looper()->CurrentMessage()->FindInt32("buttons", &buttons);
+
+    BPoint where = ConvertToScreen(point);
+
+    if ((buttons & B_SECONDARY_MOUSE_BUTTON) != 0)
+    {
+        BPopUpMenu *menu = new BPopUpMenu(B_EMPTY_STRING, false, false);
+        menu->SetAsyncAutoDestruct(true);
+        menu->SetFont(be_plain_font);
+
+        menu->AddItem(new BMenuItem("Quit", new BMessage(B_QUIT_REQUESTED)));
+        menu->SetTargetForItems(this);
+
+        menu->Go(where, true, true, true);
+    }
+}
+
+
+void VBoxGuestDeskbarView::MessageReceived(BMessage *message)
+{
+    if (message->what == B_QUIT_REQUESTED)
+        RemoveFromDeskbar();
+    else
+        BHandler::MessageReceived(message);
+}
+
 
 status_t VBoxGuestDeskbarView::AddToDeskbar(bool force)
 {
-        BDeskbar deskbar;
-        status_t err;
-        PRINT(("%s()\n", __FUNCTION__));
-
-        if (force)
-                RemoveFromDeskbar();
-        else if (deskbar.HasItem(VIEWNAME))
-                return B_OK;
-
-        app_info info;
-        err = be_app->GetAppInfo(&info);
-        PRINT(("%s: be_app->GetAppInfo: 0x%08lx\n", __FUNCTION__, err));
-        if (err < B_OK)
-                return err;
-
-        BPath p(&info.ref);
-        PRINT(("%s: app path: '%s'\n", __FUNCTION__, p.Path()));
-
-        return deskbar.AddItem(&info.ref);
-}
+    BDeskbar deskbar;
+    status_t err;
+    PRINT(("%s()\n", __FUNCTION__));
+
+    if (force)
+        RemoveFromDeskbar();
+    else if (deskbar.HasItem(VIEWNAME))
+        return B_OK;
+
+    app_info info;
+    err = be_app->GetAppInfo(&info);
+    PRINT(("%s: be_app->GetAppInfo: 0x%08lx\n", __FUNCTION__, err));
+    if (err < B_OK)
+        return err;
+
+    BPath p(&info.ref);
+    PRINT(("%s: app path: '%s'\n", __FUNCTION__, p.Path()));
+
+    return deskbar.AddItem(&info.ref);
+}
+
 
 status_t VBoxGuestDeskbarView::RemoveFromDeskbar()
 {
-        BDeskbar deskbar;
-        PRINT(("%s()\n", __FUNCTION__));
-
-        return deskbar.RemoveItem(VIEWNAME);
-}
+    BDeskbar deskbar;
+    PRINT(("%s()\n", __FUNCTION__));
+
+    return deskbar.RemoveItem(VIEWNAME);
+}
+
 
 status_t VBoxGuestDeskbarView::_Init(BMessage *archive)
 {
-        BString toolTipText;
-        toolTipText << VBOX_PRODUCT << " Guest Additions ";
-        toolTipText << VBOX_VERSION_MAJOR << "." << VBOX_VERSION_MINOR << "." << VBOX_VERSION_BUILD;
-        toolTipText << "r" << VBOX_SVN_REV;
-
-        SetToolTip(toolTipText.String());
-
-        image_info info;
-        if (our_image(info) != B_OK)
-                return B_ERROR;
-
-        BFile file(info.name, B_READ_ONLY);
-        if (file.InitCheck() < B_OK)
-                return B_ERROR;
-
-        BResources resources(&file);
-        if (resources.InitCheck() < B_OK)
-                return B_ERROR;
-
-        const void* data = NULL;
-        size_t size;
-        //data = resources.LoadResource(B_VECTOR_ICON_TYPE,
-        //      kNetworkStatusNoDevice + i, &size);
-        data = resources.LoadResource('data', 400, &size);
-        if (data != NULL) {
-                BMemoryIO mem(data, size);
-                fIcon = BTranslationUtils::GetBitmap(&mem);
-        }
+    BString toolTipText;
+    toolTipText << VBOX_PRODUCT << " Guest Additions ";
+    toolTipText << VBOX_VERSION_MAJOR << "." << VBOX_VERSION_MINOR << "." << VBOX_VERSION_BUILD;
+    toolTipText << "r" << VBOX_SVN_REV;
+
+    SetToolTip(toolTipText.String());
+
+    image_info info;
+    if (our_image(info) != B_OK)
+        return B_ERROR;
+
+    BFile file(info.name, B_READ_ONLY);
+    if (file.InitCheck() < B_OK)
+        return B_ERROR;
+
+    BResources resources(&file);
+    if (resources.InitCheck() < B_OK)
+        return B_ERROR;
+
+    const void *data = NULL;
+    size_t size;
+    //data = resources.LoadResource(B_VECTOR_ICON_TYPE,
+    //    kNetworkStatusNoDevice + i, &size);
+    data = resources.LoadResource('data', 400, &size);
+    if (data != NULL)
+    {
+        BMemoryIO mem(data, size);
+        fIcon = BTranslationUtils::GetBitmap(&mem);
+    }
 
     int rc = RTR3InitDll(0);
-        printf("%d\n", rc);
-    if (RT_SUCCESS(rc)) {
+    printf("%d\n", rc);
+    if (RT_SUCCESS(rc))
+    {
         rc = VbglR3Init();
     }
-        printf("%d\n", rc);
-        if (RT_SUCCESS(rc)) {
-                fClipboardService = new VBoxClipboardService();
-                fDisplayService = new VBoxDisplayService();
-        }
-
-        return RTErrConvertToErrno(rc);
-}
-
-extern "C" BView*
-instantiate_deskbar_item(void)
-{
-        PRINT(("%s()\n", __FUNCTION__));
-        return new VBoxGuestDeskbarView();
-}
-
+    printf("%d\n", rc);
+    if (RT_SUCCESS(rc))
+    {
+        fClipboardService = new VBoxClipboardService();
+        fDisplayService = new VBoxDisplayService();
+    }
+
+    return RTErrConvertToErrno(rc);
+}
+
+
+RTDECL(BView*) instantiate_deskbar_item()
+{
+    PRINT(("%s()\n", __FUNCTION__));
+    return new VBoxGuestDeskbarView();
+}
+

trunk/src/VBox/Additions/haiku/VBoxTray/VBoxGuestDeskbarView.h

@@ -65 +65 @@
 #define REMOVE_FROM_DESKBAR_MSG 'vbqr'
 
-class VBoxGuestDeskbarView : public BView {
-public:
-                        VBoxGuestDeskbarView();
-                        VBoxGuestDeskbarView(BMessage *archive);
-        virtual ~VBoxGuestDeskbarView();
-        static  BArchivable     *Instantiate(BMessage *data);
-        virtual status_t        Archive(BMessage *data, bool deep = true) const;
+class VBoxGuestDeskbarView : public BView
+{
+    public:
+        VBoxGuestDeskbarView();
+        VBoxGuestDeskbarView(BMessage *archive);
+        virtual ~VBoxGuestDeskbarView();
 
-                        void            Draw(BRect rect);
-                        void            AttachedToWindow();
-                        void            DetachedFromWindow();
+                static  BArchivable*   Instantiate(BMessage *data);
+        virtual status_t       Archive(BMessage *data, bool deep = true) const;
 
-        virtual void            MouseDown(BPoint point);
-        virtual void            MessageReceived(BMessage* message);
+        void                   Draw(BRect rect);
+        void                   AttachedToWindow();
+        void                   DetachedFromWindow();
 
-        static status_t         AddToDeskbar(bool force=true);
-        static status_t         RemoveFromDeskbar();
+        virtual    void        MouseDown(BPoint point);
+        virtual void           MessageReceived(BMessage *message);
 
-private:
-        status_t                        _Init(BMessage *archive=NULL);
-        BBitmap                         *fIcon;
+        static status_t        AddToDeskbar(bool force = true);
+        static status_t        RemoveFromDeskbar();
 
-        VBoxClipboardService *fClipboardService;
-        VBoxDisplayService *fDisplayService;
+    private:
+        status_t               _Init(BMessage *archive = NULL);
+        BBitmap               *fIcon;
+
+        VBoxClipboardService *fClipboardService;
+        VBoxDisplayService *fDisplayService;
 };
 
 #endif /* __VBOXGUESTTRAYVIEW__H */
+

trunk/src/VBox/Additions/haiku/VBoxVideo/accelerant/accelerant.cpp

@@ -53 +53 @@
 #define TRACE(x...) do { FILE* logfile = fopen("/var/log/vboxvideo.accelerant.log", "a"); fprintf(logfile, x); fflush(logfile); fsync(fileno(logfile)); fclose(logfile); sync(); } while(0)
 
-class AreaCloner {
-        public:
-                AreaCloner() : fArea(-1) {}
-                ~AreaCloner() {
-                        if (fArea >= B_OK)
-                                delete_area(fArea);
-                }
-
-                area_id Clone(const char *name, void **_address, uint32 spec, uint32 protection, area_id sourceArea) {
-                        fArea = clone_area(name, _address, spec, protection, sourceArea);
-                        return fArea;
-                }
-
-                status_t InitCheck() { return fArea < B_OK ? (status_t)fArea : B_OK; }
-                void Keep() { fArea = -1; }
-
-        private:
-                area_id fArea;
+class AreaCloner
+{
+    public:
+        AreaCloner() : fArea(-1) { }
+        ~AreaCloner()
+        {
+            if (fArea >= B_OK)
+                delete_area(fArea);
+        }
+
+        area_id Clone(const char *name, void **_address, uint32 spec, uint32 protection, area_id sourceArea)
+        {
+            fArea = clone_area(name, _address, spec, protection, sourceArea);
+            return fArea;
+        }
+
+        status_t InitCheck() { return fArea < B_OK ? (status_t)fArea : B_OK; }
+        void Keep() { fArea = -1; }
+
+    private:
+        area_id    fArea;
 };
 
 AccelerantInfo gInfo;
 
-static engine_token sEngineToken = {1, 0 /*B_2D_ACCELERATION*/, NULL};
-
-extern "C" void* get_accelerant_hook(uint32 feature, void* data) {
-        TRACE("%s\n", __FUNCTION__);
-        switch (feature) {
-                /* general */
-                case B_INIT_ACCELERANT:
-                        return (void*)vboxvideo_init_accelerant;
-                case B_UNINIT_ACCELERANT:
-                        return (void*)vboxvideo_uninit_accelerant;
-                case B_CLONE_ACCELERANT:
-                        return (void*)vboxvideo_clone_accelerant;
-                case B_ACCELERANT_CLONE_INFO_SIZE:
-                        return (void*)vboxvideo_accelerant_clone_info_size;
-                case B_GET_ACCELERANT_CLONE_INFO:
-                        return (void*)vboxvideo_get_accelerant_clone_info;
-                case B_GET_ACCELERANT_DEVICE_INFO:
-                        return (void*)vboxvideo_get_accelerant_device_info;
-                case B_ACCELERANT_RETRACE_SEMAPHORE:
-                        return (void*)vboxvideo_accelerant_retrace_semaphore;
-
-                /* mode configuration */
-                case B_ACCELERANT_MODE_COUNT:
-                        return (void*)vboxvideo_accelerant_mode_count;
-                case B_GET_MODE_LIST:
-                        return (void*)vboxvideo_get_mode_list;
-                case B_SET_DISPLAY_MODE:
-                        return (void*)vboxvideo_set_display_mode;
-                case B_GET_DISPLAY_MODE:
-                        return (void*)vboxvideo_get_display_mode;
-                case B_GET_EDID_INFO:
-                        return (void*)vboxvideo_get_edid_info;
-                case B_GET_FRAME_BUFFER_CONFIG:
-                        return (void*)vboxvideo_get_frame_buffer_config;
-                case B_GET_PIXEL_CLOCK_LIMITS:
-                        return (void*)vboxvideo_get_pixel_clock_limits;
-
-                /* cursor managment */
-                /*case B_SET_CURSOR_SHAPE:
-                        return (void*)vboxvideo_set_cursor_shape;
-                case B_MOVE_CURSOR:
-                        return (void*)vboxvideo_move_cursor;
-                case B_SHOW_CURSOR:
-                        return (void*)vboxvideo_show_cursor;*/
-
-                /* engine/synchronization */
-                case B_ACCELERANT_ENGINE_COUNT:
-                        return (void*)vboxvideo_accelerant_engine_count;
-                case B_ACQUIRE_ENGINE:
-                        return (void*)vboxvideo_acquire_engine;
-                case B_RELEASE_ENGINE:
-                        return (void*)vboxvideo_release_engine;
-                case B_WAIT_ENGINE_IDLE:
-                        return (void*)vboxvideo_wait_engine_idle;
-                case B_GET_SYNC_TOKEN:
-                        return (void*)vboxvideo_get_sync_token;
-                case B_SYNC_TO_TOKEN:
-                        return (void*)vboxvideo_sync_to_token;
-        }
-
-        return NULL;
-}
-
-status_t vboxvideo_init_common(int fd, bool cloned) {
-        unlink("/var/log/vboxvideo.accelerant.log"); // clear old log - next TRACE() will recreate it
-        TRACE("%s\n", __FUNCTION__);
-
-        gInfo.deviceFD = fd;
-        gInfo.isClone = cloned;
-        gInfo.sharedInfo = NULL;
-        gInfo.sharedInfoArea = -1;
-
-        area_id sharedArea;
-        if (ioctl(gInfo.deviceFD, VBOXVIDEO_GET_PRIVATE_DATA, &sharedArea, sizeof(area_id)) != 0) {
-                TRACE("ioctl failed\n");
-                return B_ERROR;
-        }
-
-        AreaCloner sharedCloner;
-        gInfo.sharedInfoArea = sharedCloner.Clone("vboxvideo shared info",
-                (void **)&gInfo.sharedInfo, B_ANY_ADDRESS,
-                B_READ_AREA | B_WRITE_AREA, sharedArea);
-        status_t status = sharedCloner.InitCheck();
-        if (status < B_OK) {
-                TRACE("InitCheck failed (%s)\n", strerror(status));
-                return status;
-        }
-        sharedCloner.Keep();
-
-        return B_OK;
-}
-
-status_t vboxvideo_init_accelerant(int fd) {
-        return vboxvideo_init_common(fd, false);
-}
-
-ssize_t vboxvideo_accelerant_clone_info_size(void) {
-        TRACE("%s\n", __FUNCTION__);
-        return B_PATH_NAME_LENGTH;
-}
-
-void vboxvideo_get_accelerant_clone_info(void *data) {
-        TRACE("%s\n", __FUNCTION__);
-        ioctl(gInfo.deviceFD, VBOXVIDEO_GET_DEVICE_NAME, data, B_PATH_NAME_LENGTH);
-}
-
-status_t vboxvideo_clone_accelerant(void *data) {
-        TRACE("%s\n", __FUNCTION__);
-
-        // create full device name
-        char path[MAXPATHLEN];
-        strcpy(path, "/dev/");
-        strcat(path, (const char *)data);
-
-        int fd = open(path, B_READ_WRITE);
-        if (fd < 0)
-                return errno;
-
-        return vboxvideo_init_common(fd, true);
-}
-
-void vboxvideo_uninit_accelerant(void) {
-        delete_area(gInfo.sharedInfoArea);
-        gInfo.sharedInfo = NULL;
-        gInfo.sharedInfoArea = -1;
-
-        if (gInfo.isClone)
-                close(gInfo.deviceFD);
-
-        TRACE("%s\n", __FUNCTION__);
-}
-
-status_t vboxvideo_get_accelerant_device_info(accelerant_device_info *adi) {
-        TRACE("%s\n", __FUNCTION__);
-        adi->version = B_ACCELERANT_VERSION;
-        strcpy(adi->name, "Virtual display");
-        strcpy(adi->chipset, "VirtualBox Graphics Adapter");
-        strcpy(adi->serial_no, "9001");
-        return B_OK;
-}
-
-sem_id vboxvideo_accelerant_retrace_semaphore(void) {
-        TRACE("%s\n", __FUNCTION__);
-        return -1;
+static engine_token sEngineToken = { 1, 0 /*B_2D_ACCELERATION*/, NULL };
+
+extern "C"
+void* get_accelerant_hook(uint32 feature, void *data)
+{
+    TRACE("%s\n", __FUNCTION__);
+    switch (feature)
+    {
+        /* general */
+        case B_INIT_ACCELERANT:
+            return (void *)vboxvideo_init_accelerant;
+        case B_UNINIT_ACCELERANT:
+            return (void *)vboxvideo_uninit_accelerant;
+        case B_CLONE_ACCELERANT:
+            return (void *)vboxvideo_clone_accelerant;
+        case B_ACCELERANT_CLONE_INFO_SIZE:
+            return (void *)vboxvideo_accelerant_clone_info_size;
+        case B_GET_ACCELERANT_CLONE_INFO:
+            return (void *)vboxvideo_get_accelerant_clone_info;
+        case B_GET_ACCELERANT_DEVICE_INFO:
+            return (void *)vboxvideo_get_accelerant_device_info;
+        case B_ACCELERANT_RETRACE_SEMAPHORE:
+            return (void *)vboxvideo_accelerant_retrace_semaphore;
+
+            /* mode configuration */
+        case B_ACCELERANT_MODE_COUNT:
+            return (void *)vboxvideo_accelerant_mode_count;
+        case B_GET_MODE_LIST:
+            return (void *)vboxvideo_get_mode_list;
+        case B_SET_DISPLAY_MODE:
+            return (void *)vboxvideo_set_display_mode;
+        case B_GET_DISPLAY_MODE:
+            return (void *)vboxvideo_get_display_mode;
+        case B_GET_EDID_INFO:
+            return (void *)vboxvideo_get_edid_info;
+        case B_GET_FRAME_BUFFER_CONFIG:
+            return (void *)vboxvideo_get_frame_buffer_config;
+        case B_GET_PIXEL_CLOCK_LIMITS:
+            return (void *)vboxvideo_get_pixel_clock_limits;
+
+            /* cursor managment */
+            /*case B_SET_CURSOR_SHAPE:
+                return (void*)vboxvideo_set_cursor_shape;
+            case B_MOVE_CURSOR:
+                return (void*)vboxvideo_move_cursor;
+            case B_SHOW_CURSOR:
+                return (void*)vboxvideo_show_cursor;*/
+
+            /* engine/synchronization */
+        case B_ACCELERANT_ENGINE_COUNT:
+            return (void *)vboxvideo_accelerant_engine_count;
+        case B_ACQUIRE_ENGINE:
+            return (void *)vboxvideo_acquire_engine;
+        case B_RELEASE_ENGINE:
+            return (void *)vboxvideo_release_engine;
+        case B_WAIT_ENGINE_IDLE:
+            return (void *)vboxvideo_wait_engine_idle;
+        case B_GET_SYNC_TOKEN:
+            return (void *)vboxvideo_get_sync_token;
+        case B_SYNC_TO_TOKEN:
+            return (void *)vboxvideo_sync_to_token;
+    }
+
+    return NULL;
+}
+
+status_t vboxvideo_init_common(int fd, bool cloned)
+{
+    unlink("/var/log/vboxvideo.accelerant.log"); // clear old log - next TRACE() will recreate it
+    TRACE("%s\n", __FUNCTION__);
+
+    gInfo.deviceFD = fd;
+    gInfo.isClone = cloned;
+    gInfo.sharedInfo = NULL;
+    gInfo.sharedInfoArea = -1;
+
+    area_id sharedArea;
+    if (ioctl(gInfo.deviceFD, VBOXVIDEO_GET_PRIVATE_DATA, &sharedArea, sizeof(area_id)) != 0)
+    {
+        TRACE("ioctl failed\n");
+        return B_ERROR;
+    }
+
+    AreaCloner sharedCloner;
+    gInfo.sharedInfoArea = sharedCloner.Clone("vboxvideo shared info",
+                                              (void **)&gInfo.sharedInfo, B_ANY_ADDRESS,
+                                              B_READ_AREA | B_WRITE_AREA, sharedArea);
+    status_t status = sharedCloner.InitCheck();
+    if (status < B_OK)
+    {
+        TRACE("InitCheck failed (%s)\n", strerror(status));
+        return status;
+    }
+    sharedCloner.Keep();
+
+    return B_OK;
+}
+
+status_t vboxvideo_init_accelerant(int fd)
+{
+    return vboxvideo_init_common(fd, false);
+}
+
+ssize_t vboxvideo_accelerant_clone_info_size(void)
+{
+    TRACE("%s\n", __FUNCTION__);
+    return B_PATH_NAME_LENGTH;
+}
+
+void vboxvideo_get_accelerant_clone_info(void *data)
+{
+    TRACE("%s\n", __FUNCTION__);
+    ioctl(gInfo.deviceFD, VBOXVIDEO_GET_DEVICE_NAME, data, B_PATH_NAME_LENGTH);
+}
+
+status_t vboxvideo_clone_accelerant(void *data)
+{
+    TRACE("%s\n", __FUNCTION__);
+
+    // create full device name
+    char path[MAXPATHLEN];
+    strcpy(path, "/dev/");
+    strcat(path, (const char *)data);
+
+    int fd = open(path, B_READ_WRITE);
+    if (fd < 0)
+        return errno;
+
+    return vboxvideo_init_common(fd, true);
+}
+
+void vboxvideo_uninit_accelerant(void)
+{
+    delete_area(gInfo.sharedInfoArea);
+    gInfo.sharedInfo = NULL;
+    gInfo.sharedInfoArea = -1;
+
+    if (gInfo.isClone)
+        close(gInfo.deviceFD);
+
+    TRACE("%s\n", __FUNCTION__);
+}
+
+status_t vboxvideo_get_accelerant_device_info(accelerant_device_info *adi)
+{
+    TRACE("%s\n", __FUNCTION__);
+    adi->version = B_ACCELERANT_VERSION;
+    strcpy(adi->name, "Virtual display");
+    strcpy(adi->chipset, "VirtualBox Graphics Adapter");
+    strcpy(adi->serial_no, "9001");
+    return B_OK;
+}
+
+sem_id vboxvideo_accelerant_retrace_semaphore(void)
+{
+    TRACE("%s\n", __FUNCTION__);
+    return -1;
 }
 
 // modes & constraints
-uint32 vboxvideo_accelerant_mode_count(void) {
-        TRACE("%s\n", __FUNCTION__);
-        return 1;
-}
-
-status_t vboxvideo_get_mode_list(display_mode *dm) {
-        // TODO return some standard modes here
-        TRACE("%s\n", __FUNCTION__);
-        return vboxvideo_get_display_mode(dm);
-}
-
-status_t vboxvideo_set_display_mode(display_mode *modeToSet) {
-        TRACE("%s\n", __FUNCTION__);
-        TRACE("trying to set mode %dx%d\n", modeToSet->timing.h_display, modeToSet->timing.v_display);
-        return ioctl(gInfo.deviceFD, VBOXVIDEO_SET_DISPLAY_MODE, modeToSet, sizeof(display_mode));
-}
-
-status_t vboxvideo_get_display_mode(display_mode *currentMode) {
-        TRACE("%s\n", __FUNCTION__);
-        *currentMode = gInfo.sharedInfo->currentMode;
-        TRACE("current mode is %dx%d\n", currentMode->timing.h_display, currentMode->timing.v_display);
-        return B_OK;
-}
-
-status_t vboxvideo_get_edid_info(void *info, size_t size, uint32 *_version) {
-        TRACE("%s\n", __FUNCTION__);
-
-        // copied from the X11 implementation:
-        static const uint8 edid_data[128] = {
-                0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, /* header */
-                0x58, 0x58, /* manufacturer (VBX) */
-                0x00, 0x00, /* product code */
-                0x00, 0x00, 0x00, 0x00, /* serial number goes here */
-                0x01, /* week of manufacture */
-                0x00, /* year of manufacture */
-                0x01, 0x03, /* EDID version */
-                0x80, /* capabilities - digital */
-                0x00, /* horiz. res in cm, zero for projectors */
-                0x00, /* vert. res in cm */
-                0x78, /* display gamma (120 == 2.2).  Should we ask the host for this? */
-                0xEE, /* features (standby, suspend, off, RGB, standard colour space,
-                                * preferred timing mode) */
-                0xEE, 0x91, 0xA3, 0x54, 0x4C, 0x99, 0x26, 0x0F, 0x50, 0x54,
-                        /* chromaticity for standard colour space - should we ask the host? */
-                0x00, 0x00, 0x00, /* no default timings */
-                0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
-                0x01, 0x01, 0x01, 0x01, /* no standard timings */
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* descriptor block 1 goes here */
-                0x00, 0x00, 0x00, 0xFD, 0x00, /* descriptor block 2, monitor ranges */
-                0x00, 0xC8, 0x00, 0xC8, 0x64, 0x00, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20,
-                0x20, /* 0-200Hz vertical, 0-200KHz horizontal, 1000MHz pixel clock */
-                0x00, 0x00, 0x00, 0xFC, 0x00, /* descriptor block 3, monitor name */
-                'V', 'B', 'O', 'X', ' ', 'm', 'o', 'n', 'i', 't', 'o', 'r', '\n',
-                0x00, 0x00, 0x00, 0x10, 0x00, /* descriptor block 4: dummy data */
-                0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
-                0x20,
-                0x00, /* number of extensions */
-                0x00 /* checksum goes here */
-        };
-
-        if (size < 128)
-                return B_BUFFER_OVERFLOW;
-
-        *_version = 1; /*EDID_VERSION_1*/
-        memcpy(info, edid_data, 128);
-        return B_OK;
-}
-
-status_t vboxvideo_get_frame_buffer_config(frame_buffer_config *config) {
-        TRACE("%s\n", __FUNCTION__);
-        config->frame_buffer = gInfo.sharedInfo->framebuffer;
-        config->frame_buffer_dma = NULL;
-        config->bytes_per_row = get_depth_for_color_space(gInfo.sharedInfo->currentMode.space)
-                * gInfo.sharedInfo->currentMode.timing.h_display / 8;
-        return B_OK;
-}
-
-status_t vboxvideo_get_pixel_clock_limits(display_mode *dm, uint32 *low, uint32 *high) {
-        TRACE("%s\n", __FUNCTION__);
-        // irrelevant for virtual monitors
-        *low = 0;
-        *high = 9001;
-        return B_OK;
+uint32 vboxvideo_accelerant_mode_count(void)
+{
+    TRACE("%s\n", __FUNCTION__);
+    return 1;
+}
+
+status_t vboxvideo_get_mode_list(display_mode *dm)
+{
+    // TODO return some standard modes here
+    TRACE("%s\n", __FUNCTION__);
+    return vboxvideo_get_display_mode(dm);
+}
+
+status_t vboxvideo_set_display_mode(display_mode *modeToSet)
+{
+    TRACE("%s\n", __FUNCTION__);
+    TRACE("trying to set mode %dx%d\n", modeToSet->timing.h_display, modeToSet->timing.v_display);
+    return ioctl(gInfo.deviceFD, VBOXVIDEO_SET_DISPLAY_MODE, modeToSet, sizeof(display_mode));
+}
+
+status_t vboxvideo_get_display_mode(display_mode *currentMode)
+{
+    TRACE("%s\n", __FUNCTION__);
+    *currentMode = gInfo.sharedInfo->currentMode;
+    TRACE("current mode is %dx%d\n", currentMode->timing.h_display, currentMode->timing.v_display);
+    return B_OK;
+}
+
+status_t vboxvideo_get_edid_info(void *info, size_t size, uint32 *_version)
+{
+    TRACE("%s\n", __FUNCTION__);
+
+    // copied from the X11 implementation:
+    static const uint8 edid_data[128] = {
+        0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, /* header */
+        0x58, 0x58, /* manufacturer (VBX) */
+        0x00, 0x00, /* product code */
+        0x00, 0x00, 0x00, 0x00, /* serial number goes here */
+        0x01, /* week of manufacture */
+        0x00, /* year of manufacture */
+        0x01, 0x03, /* EDID version */
+        0x80, /* capabilities - digital */
+        0x00, /* horiz. res in cm, zero for projectors */
+        0x00, /* vert. res in cm */
+        0x78, /* display gamma (120 == 2.2).  Should we ask the host for this? */
+        0xEE, /* features (standby, suspend, off, RGB, standard colour space,
+                * preferred timing mode) */
+        0xEE, 0x91, 0xA3, 0x54, 0x4C, 0x99, 0x26, 0x0F, 0x50, 0x54,
+        /* chromaticity for standard colour space - should we ask the host? */
+        0x00, 0x00, 0x00, /* no default timings */
+        0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
+        0x01, 0x01, 0x01, 0x01, /* no standard timings */
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* descriptor block 1 goes here */
+        0x00, 0x00, 0x00, 0xFD, 0x00, /* descriptor block 2, monitor ranges */
+        0x00, 0xC8, 0x00, 0xC8, 0x64, 0x00, 0x0A, 0x20, 0x20, 0x20, 0x20, 0x20,
+        0x20, /* 0-200Hz vertical, 0-200KHz horizontal, 1000MHz pixel clock */
+        0x00, 0x00, 0x00, 0xFC, 0x00, /* descriptor block 3, monitor name */
+        'V', 'B', 'O', 'X', ' ', 'm', 'o', 'n', 'i', 't', 'o', 'r', '\n',
+        0x00, 0x00, 0x00, 0x10, 0x00, /* descriptor block 4: dummy data */
+        0x0A, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
+        0x20,
+        0x00, /* number of extensions */
+        0x00 /* checksum goes here */
+    };
+
+    if (size < 128)
+        return B_BUFFER_OVERFLOW;
+
+    *_version = 1; /*EDID_VERSION_1*/
+    memcpy(info, edid_data, 128);
+    return B_OK;
+}
+
+status_t vboxvideo_get_frame_buffer_config(frame_buffer_config *config)
+{
+    TRACE("%s\n", __FUNCTION__);
+    config->frame_buffer = gInfo.sharedInfo->framebuffer;
+    config->frame_buffer_dma = NULL;
+    config->bytes_per_row = get_depth_for_color_space(gInfo.sharedInfo->currentMode.space)
+                            * gInfo.sharedInfo->currentMode.timing.h_display / 8;
+    return B_OK;
+}
+
+status_t vboxvideo_get_pixel_clock_limits(display_mode *dm, uint32 *low, uint32 *high)
+{
+    TRACE("%s\n", __FUNCTION__);
+    // irrelevant for virtual monitors
+    *low = 0;
+    *high = 9001;
+    return B_OK;
 }
 
 // cursor
-status_t vboxvideo_set_cursor_shape(uint16 width, uint16 height, uint16 hotX, uint16 hotY, uint8 *andMask, uint8 *xorMask) {
-        TRACE("%s\n", __FUNCTION__);
-        // VBoxHGSMIUpdatePointerShape
-        return B_UNSUPPORTED;
-}
-
-void vboxvideo_move_cursor(uint16 x, uint16 y) {
-        TRACE("%s\n", __FUNCTION__);
-}
-
-void vboxvideo_show_cursor(bool is_visible) {
-        TRACE("%s\n", __FUNCTION__);
+status_t vboxvideo_set_cursor_shape(uint16 width, uint16 height, uint16 hotX, uint16 hotY, uint8 *andMask, uint8 *xorMask)
+{
+    TRACE("%s\n", __FUNCTION__);
+    // VBoxHGSMIUpdatePointerShape
+    return B_UNSUPPORTED;
+}
+
+void vboxvideo_move_cursor(uint16 x, uint16 y)
+{
+    TRACE("%s\n", __FUNCTION__);
+}
+
+void vboxvideo_show_cursor(bool is_visible)
+{
+    TRACE("%s\n", __FUNCTION__);
 }
 
 // accelerant engine
-uint32 vboxvideo_accelerant_engine_count(void) {
-        TRACE("%s\n", __FUNCTION__);
-        return 1;
-}
-
-status_t vboxvideo_acquire_engine(uint32 capabilities, uint32 maxWait, sync_token *st, engine_token **et) {
-        TRACE("%s\n", __FUNCTION__);
-        *et = &sEngineToken;
-        return B_OK;
-}
-
-status_t vboxvideo_release_engine(engine_token *et, sync_token *st) {
-        TRACE("%s\n", __FUNCTION__);
-        if (st != NULL)
-                st->engine_id = et->engine_id;
-
-        return B_OK;
-}
-
-void vboxvideo_wait_engine_idle(void) {
-        TRACE("%s\n", __FUNCTION__);
-}
-
-status_t vboxvideo_get_sync_token(engine_token *et, sync_token *st) {
-        TRACE("%s\n", __FUNCTION__);
-        return B_OK;
-}
-
-status_t vboxvideo_sync_to_token(sync_token *st) {
-        TRACE("%s\n", __FUNCTION__);
-        return B_OK;
+uint32 vboxvideo_accelerant_engine_count(void)
+{
+    TRACE("%s\n", __FUNCTION__);
+    return 1;
+}
+
+status_t vboxvideo_acquire_engine(uint32 capabilities, uint32 maxWait, sync_token *st, engine_token **et)
+{
+    TRACE("%s\n", __FUNCTION__);
+    *et = &sEngineToken;
+    return B_OK;
+}
+
+status_t vboxvideo_release_engine(engine_token *et, sync_token *st)
+{
+    TRACE("%s\n", __FUNCTION__);
+    if (st != NULL)
+        st->engine_id = et->engine_id;
+
+    return B_OK;
+}
+
+void vboxvideo_wait_engine_idle(void)
+{
+    TRACE("%s\n", __FUNCTION__);
+}
+
+status_t vboxvideo_get_sync_token(engine_token *et, sync_token *st)
+{
+    TRACE("%s\n", __FUNCTION__);
+    return B_OK;
+}
+
+status_t vboxvideo_sync_to_token(sync_token *st)
+{
+    TRACE("%s\n", __FUNCTION__);
+    return B_OK;
 }
 
 // 2D acceleration
-void vboxvideo_screen_to_screen_blit(engine_token *et, blit_params *list, uint32 count) {
-        TRACE("%s\n", __FUNCTION__);
-}
-
-void vboxvideo_fill_rectangle(engine_token *et, uint32 color, fill_rect_params *list, uint32 count) {
-        TRACE("%s\n", __FUNCTION__);
-}
-
-void vboxvideo_invert_rectangle(engine_token *et, fill_rect_params *list, uint32 count) {
-        TRACE("%s\n", __FUNCTION__);
-}
-
-void vboxvideo_fill_span(engine_token *et, uint32 color, uint16 *list, uint32 count) {
-        TRACE("%s\n", __FUNCTION__);
-}
+void vboxvideo_screen_to_screen_blit(engine_token *et, blit_params *list, uint32 count)
+{
+    TRACE("%s\n", __FUNCTION__);
+}
+
+void vboxvideo_fill_rectangle(engine_token *et, uint32 color, fill_rect_params *list, uint32 count)
+{
+    TRACE("%s\n", __FUNCTION__);
+}
+
+void vboxvideo_invert_rectangle(engine_token *et, fill_rect_params *list, uint32 count)
+{
+    TRACE("%s\n", __FUNCTION__);
+}
+
+void vboxvideo_fill_span(engine_token *et, uint32 color, uint16 *list, uint32 count)
+{
+    TRACE("%s\n", __FUNCTION__);
+}

trunk/src/VBox/Additions/haiku/VBoxVideo/accelerant/accelerant.h

@@ -51 +51 @@
 #include "../common/VBoxVideo_common.h"
 
-struct AccelerantInfo {
-        int deviceFD;
-        bool isClone;
+struct AccelerantInfo
+{
+        int deviceFD;
+        bool isClone;
 
-        SharedInfo* sharedInfo;
-        area_id sharedInfoArea;
+        SharedInfo *sharedInfo;
+        area_id sharedInfoArea;
 };
 extern AccelerantInfo gInfo;
@@ -97 +98 @@
 void vboxvideo_fill_span(engine_token *et, uint32 color, uint16 *list, uint32 count);
 
-#endif  /* _ACCELERANT_PROTOS_H */
+#endif    /* _ACCELERANT_PROTOS_H */

trunk/src/VBox/Additions/haiku/VBoxVideo/common/VBoxVideo_common.h

@@ -52 +52 @@
 #include <PCI.h>
 
-struct SharedInfo {
-        display_mode currentMode;
-
-        area_id framebufferArea;
-        void* framebuffer;
+struct SharedInfo
+{
+        display_mode currentMode;
+        area_id framebufferArea;
+        void *framebuffer;
 };
 
-enum {
-        VBOXVIDEO_GET_PRIVATE_DATA = B_DEVICE_OP_CODES_END + 1,
-        VBOXVIDEO_GET_DEVICE_NAME,
-        VBOXVIDEO_SET_DISPLAY_MODE
+enum
+{
+    VBOXVIDEO_GET_PRIVATE_DATA = B_DEVICE_OP_CODES_END + 1,
+    VBOXVIDEO_GET_DEVICE_NAME,
+    VBOXVIDEO_SET_DISPLAY_MODE
 };
 
 static inline uint32 get_color_space_for_depth(uint32 depth)
 {
-        switch (depth) {
-                case 1:
-                        return B_GRAY1;
-                case 4:
-                        return B_GRAY8;
-                                // the app_server is smart enough to translate this to VGA mode
-                case 8:
-                        return B_CMAP8;
-                case 15:
-                        return B_RGB15;
-                case 16:
-                        return B_RGB16;
-                case 24:
-                        return B_RGB24;
-                case 32:
-                        return B_RGB32;
-        }
+    switch (depth)
+    {
+        case 1:  return B_GRAY1;
+        case 4:  return B_GRAY8;
+                // the app_server is smart enough to translate this to VGA mode
+        case 8:  return B_CMAP8;
+        case 15: return B_RGB15;
+        case 16: return B_RGB16;
+        case 24: return B_RGB24;
+        case 32: return B_RGB32;
+    }
 
-        return 0;
+    return 0;
 }
 
 static inline uint32 get_depth_for_color_space(uint32 depth)
 {
-        switch (depth) {
-                case B_GRAY1:
-                        return 1;
-                case B_GRAY8:
-                        return 4;
-                case B_CMAP8:
-                        return 8;
-                case B_RGB15:
-                        return 15;
-                case B_RGB16:
-                        return 16;
-                case B_RGB24:
-                        return 24;
-                case B_RGB32:
-                        return 32;
-        }
-
-        return 0;
+    switch (depth)
+    {
+        case B_GRAY1: return 1;
+        case B_GRAY8: return 4;
+        case B_CMAP8: return 8;
+        case B_RGB15: return 15;
+        case B_RGB16: return 16;
+        case B_RGB24: return 24;
+        case B_RGB32: return 32;
+    }
+    return 0;
 }
 
-#endif
+#endif /* _VBOXVIDEO_COMMON_H */
+

trunk/src/VBox/Additions/haiku/VBoxVideo/driver/driver.cpp

@@ -66 +66 @@
 #undef TRACE
 #ifdef ENABLE_DEBUG_TRACE
-#       define TRACE(x...) dprintf("VBoxVideo: " x)
+#define TRACE(x...) dprintf("VBoxVideo: " x)
 #else
-#       define TRACE(x...) ;
+#define TRACE(x...) ;
 #endif
 
@@ -75 +75 @@
 extern "C" status_t vm_set_area_memory_type(area_id id, phys_addr_t physicalBase, uint32 type);
 
-struct Benaphore {
-        sem_id  sem;
-        int32   count;
-
-        status_t Init(const char* name)
-        {
-                count = 0;
-                sem = create_sem(0, name);
-                return sem < 0 ? sem : B_OK;
-        }
-
-        status_t Acquire()
-        {
-                if (atomic_add(&count, 1) > 0)
-                        return acquire_sem(sem);
-                return B_OK;
-        }
-
-        status_t Release()
-        {
-                if (atomic_add(&count, -1) > 1)
-                        return release_sem(sem);
-                return B_OK;
-        }
-
-        void Delete() { delete_sem(sem); }
+struct Benaphore
+{
+        sem_id    sem;
+        int32    count;
+
+        status_t Init(const char *name)
+        {
+            count = 0;
+            sem = create_sem(0, name);
+            return sem < 0 ? sem : B_OK;
+        }
+
+        status_t Acquire()
+        {
+            if (atomic_add(&count, 1) > 0)
+                return acquire_sem(sem);
+            return B_OK;
+        }
+
+        status_t Release()
+        {
+            if (atomic_add(&count, -1) > 1)
+                return release_sem(sem);
+            return B_OK;
+        }
+
+        void Delete()
+                {
+                        delete_sem(sem);
+                }
 };
 
-struct DeviceInfo {
-        uint32                  openCount;              // count of how many times device has been opened
-        uint32                  flags;
-        area_id                 sharedArea;             // area shared between driver and all accelerants
-        SharedInfo*             sharedInfo;             // pointer to shared info area memory
-        pci_info                pciInfo;                // copy of pci info for this device
-        char                    name[B_OS_NAME_LENGTH]; // name of device
+struct DeviceInfo
+{
+        uint32          openCount;                      // count of how many times device has been opened
+        uint32          flags;                                  // device flags
+        area_id         sharedArea;                     // area shared between driver and all accelerants
+        SharedInfo     *sharedInfo;                     // pointer to shared info area memory
+        pci_info        pciInfo;                        // copy of pci info for this device
+        char            name[B_OS_NAME_LENGTH]; // name of device
 };
 
 // at most one virtual video card ever appears, no reason for this to be an array
 static DeviceInfo gDeviceInfo;
-static char* gDeviceNames[2] = {gDeviceInfo.name, NULL};
+static char *gDeviceNames[2] = { gDeviceInfo.name, NULL };
 static bool gCanHasDevice = false; // is the device present?
 static Benaphore gLock;
-static pci_module_info* gPCI;
-
-status_t device_open(const char* name, uint32 flags, void** cookie);
-status_t device_close(void* dev);
-status_t device_free(void* dev);
-status_t device_read(void* dev, off_t pos, void* buf, size_t* len);
-status_t device_write(void* dev, off_t pos, const void* buf, size_t* len);
-status_t device_ioctl(void* dev, uint32 msg, void* buf, size_t len);
+static pci_module_info *gPCI;
+
+status_t device_open(const char *name, uint32 flags, void **cookie);
+status_t device_close(void *dev);
+status_t device_free(void *dev);
+status_t device_read(void *dev, off_t pos, void *buf, size_t *len);
+status_t device_write(void *dev, off_t pos, const void *buf, size_t *len);
+status_t device_ioctl(void *dev, uint32 msg, void *buf, size_t len);
 static uint32 get_color_space_for_depth(uint32 depth);
 
-static device_hooks gDeviceHooks = {
-        device_open, // open
-        device_close, // close
-        device_free, // free
-        device_ioctl, // control
-        device_read, // read
-        device_write, // write
-        NULL, // select
-        NULL, // deselect
-        NULL, // read_pages
-        NULL  // write_pages
+static device_hooks gDeviceHooks =
+{
+    device_open, // open
+    device_close, // close
+    device_free, // free
+    device_ioctl, // control
+    device_read, // read
+    device_write, // write
+    NULL, // select
+    NULL, // deselect
+    NULL, // read_pages
+    NULL  // write_pages
 };
 
 status_t init_hardware()
 {
-        TRACE("init_hardware\n");
-
-        if (get_module(VBOXGUEST_MODULE_NAME, (module_info **)&g_VBoxGuest) != B_OK) {
-                dprintf("get_module(%s) failed\n", VBOXGUEST_MODULE_NAME);
-                return B_ERROR;
-        }
-
-        if (get_module(B_PCI_MODULE_NAME, (module_info **)&gPCI) != B_OK) {
-                dprintf("get_module(%s) failed\n", B_PCI_MODULE_NAME);
-                return B_ERROR;
-        }
-
-        return B_OK;
+    TRACE("init_hardware\n");
+
+    if (get_module(VBOXGUEST_MODULE_NAME, (module_info **)&g_VBoxGuest) != B_OK)
+    {
+        dprintf("get_module(%s) failed\n", VBOXGUEST_MODULE_NAME);
+        return B_ERROR;
+    }
+
+    if (get_module(B_PCI_MODULE_NAME, (module_info **)&gPCI) != B_OK)
+    {
+        dprintf("get_module(%s) failed\n", B_PCI_MODULE_NAME);
+        return B_ERROR;
+    }
+
+    return B_OK;
 }
 
 status_t init_driver()
 {
-        TRACE("init_driver\n");
-
-        gLock.Init("VBoxVideo driver lock");
-
-        uint32 pciIndex = 0;
-
-        while (gPCI->get_nth_pci_info(pciIndex, &gDeviceInfo.pciInfo) == B_OK) {
-                if (gDeviceInfo.pciInfo.vendor_id == VENDOR_ID && gDeviceInfo.pciInfo.device_id == DEVICE_ID) {
-                        sprintf(gDeviceInfo.name, "graphics/" DEVICE_FORMAT,
-                                gDeviceInfo.pciInfo.vendor_id, gDeviceInfo.pciInfo.device_id,
-                                gDeviceInfo.pciInfo.bus, gDeviceInfo.pciInfo.device, gDeviceInfo.pciInfo.function);
-                        TRACE("found device %s\n", gDeviceInfo.name);
-
-                        gCanHasDevice = true;
-                        gDeviceInfo.openCount = 0;
-
-                        size_t sharedSize = (sizeof(SharedInfo) + 7) & ~7;
-                        gDeviceInfo.sharedArea = create_area("vboxvideo shared info",
-                                (void**)&gDeviceInfo.sharedInfo, B_ANY_KERNEL_ADDRESS,
-                                ROUND_TO_PAGE_SIZE(sharedSize), B_FULL_LOCK,
-                                B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA | B_USER_CLONEABLE_AREA);
-
-                        uint16_t width, height, vwidth, bpp, flags;
-                        VBoxVideoGetModeRegisters(&width, &height, &vwidth, &bpp, &flags);
-
-                        gDeviceInfo.sharedInfo->currentMode.space = get_color_space_for_depth(bpp);
-                        gDeviceInfo.sharedInfo->currentMode.virtual_width = width;
-                        gDeviceInfo.sharedInfo->currentMode.virtual_height = height;
-                        gDeviceInfo.sharedInfo->currentMode.h_display_start = 0;
-                        gDeviceInfo.sharedInfo->currentMode.v_display_start = 0;
-                        gDeviceInfo.sharedInfo->currentMode.flags = 0;
-                        gDeviceInfo.sharedInfo->currentMode.timing.h_display = width;
-                        gDeviceInfo.sharedInfo->currentMode.timing.v_display = height;
-                        // not used, but this makes a reasonable-sounding refresh rate show in screen prefs:
-                        gDeviceInfo.sharedInfo->currentMode.timing.h_total = 1000;
-                        gDeviceInfo.sharedInfo->currentMode.timing.v_total = 1;
-                        gDeviceInfo.sharedInfo->currentMode.timing.pixel_clock = 850;
-
-                        // map the PCI memory space
-                        uint32 command_reg = gPCI->read_pci_config(gDeviceInfo.pciInfo.bus,
-                                gDeviceInfo.pciInfo.device, gDeviceInfo.pciInfo.function,  PCI_command, 2);
-                        command_reg |= PCI_command_io | PCI_command_memory | PCI_command_master;
-                        gPCI->write_pci_config(gDeviceInfo.pciInfo.bus, gDeviceInfo.pciInfo.device,
-                                gDeviceInfo.pciInfo.function, PCI_command, 2, command_reg);
-
-                        gDeviceInfo.sharedInfo->framebufferArea =
-                                map_physical_memory("vboxvideo framebuffer", (phys_addr_t)gDeviceInfo.pciInfo.u.h0.base_registers[0],
-                                        gDeviceInfo.pciInfo.u.h0.base_register_sizes[0], B_ANY_KERNEL_BLOCK_ADDRESS,
-                                        B_READ_AREA | B_WRITE_AREA, &(gDeviceInfo.sharedInfo->framebuffer));
-                        vm_set_area_memory_type(gDeviceInfo.sharedInfo->framebufferArea,
-                                (phys_addr_t)gDeviceInfo.pciInfo.u.h0.base_registers[0], B_MTR_WC);
-
-                        break;
-                }
-
-                pciIndex++;
-        }
-
-        return B_OK;
-}
+    TRACE("init_driver\n");
+
+    gLock.Init("VBoxVideo driver lock");
+
+    uint32 pciIndex = 0;
+
+    while (gPCI->get_nth_pci_info(pciIndex, &gDeviceInfo.pciInfo) == B_OK)
+    {
+        if (gDeviceInfo.pciInfo.vendor_id == VENDOR_ID && gDeviceInfo.pciInfo.device_id == DEVICE_ID)
+        {
+            sprintf(gDeviceInfo.name, "graphics/" DEVICE_FORMAT,
+                    gDeviceInfo.pciInfo.vendor_id, gDeviceInfo.pciInfo.device_id,
+                    gDeviceInfo.pciInfo.bus, gDeviceInfo.pciInfo.device, gDeviceInfo.pciInfo.function);
+            TRACE("found device %s\n", gDeviceInfo.name);
+
+            gCanHasDevice = true;
+            gDeviceInfo.openCount = 0;
+
+            size_t sharedSize = (sizeof(SharedInfo) + 7) & ~7;
+            gDeviceInfo.sharedArea = create_area("vboxvideo shared info",
+                                                 (void **)&gDeviceInfo.sharedInfo, B_ANY_KERNEL_ADDRESS,
+                                                 ROUND_TO_PAGE_SIZE(sharedSize), B_FULL_LOCK,
+                                                 B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA | B_USER_CLONEABLE_AREA);
+
+            uint16_t width, height, vwidth, bpp, flags;
+            VBoxVideoGetModeRegisters(&width, &height, &vwidth, &bpp, &flags);
+
+            gDeviceInfo.sharedInfo->currentMode.space = get_color_space_for_depth(bpp);
+            gDeviceInfo.sharedInfo->currentMode.virtual_width = width;
+            gDeviceInfo.sharedInfo->currentMode.virtual_height = height;
+            gDeviceInfo.sharedInfo->currentMode.h_display_start = 0;
+            gDeviceInfo.sharedInfo->currentMode.v_display_start = 0;
+            gDeviceInfo.sharedInfo->currentMode.flags = 0;
+            gDeviceInfo.sharedInfo->currentMode.timing.h_display = width;
+            gDeviceInfo.sharedInfo->currentMode.timing.v_display = height;
+            // not used, but this makes a reasonable-sounding refresh rate show in screen prefs:
+            gDeviceInfo.sharedInfo->currentMode.timing.h_total = 1000;
+            gDeviceInfo.sharedInfo->currentMode.timing.v_total = 1;
+            gDeviceInfo.sharedInfo->currentMode.timing.pixel_clock = 850;
+
+            // map the PCI memory space
+            uint32 command_reg = gPCI->read_pci_config(gDeviceInfo.pciInfo.bus,
+                                                       gDeviceInfo.pciInfo.device, gDeviceInfo.pciInfo.function,  PCI_command, 2);
+            command_reg |= PCI_command_io | PCI_command_memory | PCI_command_master;
+            gPCI->write_pci_config(gDeviceInfo.pciInfo.bus, gDeviceInfo.pciInfo.device,
+                                   gDeviceInfo.pciInfo.function, PCI_command, 2, command_reg);
+
+            gDeviceInfo.sharedInfo->framebufferArea = map_physical_memory("vboxvideo framebuffer",
+                                                      (phys_addr_t)gDeviceInfo.pciInfo.u.h0.base_registers[0],
+                                                      gDeviceInfo.pciInfo.u.h0.base_register_sizes[0], B_ANY_KERNEL_BLOCK_ADDRESS,
+                                                      B_READ_AREA | B_WRITE_AREA, &(gDeviceInfo.sharedInfo->framebuffer));
+            vm_set_area_memory_type(gDeviceInfo.sharedInfo->framebufferArea,
+                                    (phys_addr_t)gDeviceInfo.pciInfo.u.h0.base_registers[0], B_MTR_WC);
+            break;
+        }
+
+        pciIndex++;
+    }
+
+    return B_OK;
+}
+
 
 const char** publish_devices()
 {
-        TRACE("publish_devices\n");
-        if (gCanHasDevice) {
-                return (const char**)gDeviceNames;
-        }
-        else {
-                return NULL;
-        }
-}
-
-device_hooks* find_device(const char* name)
-{
-        TRACE("find_device\n");
-        if (gCanHasDevice && strcmp(name, gDeviceInfo.name) == 0) {
-                return &gDeviceHooks;
-        }
-        else {
-                return NULL;
-        }
-}
+    TRACE("publish_devices\n");
+    if (gCanHasDevice)
+        return (const char **)gDeviceNames;
+    return NULL;
+}
+
+
+device_hooks* find_device(const char *name)
+{
+    TRACE("find_device\n");
+    if (gCanHasDevice && strcmp(name, gDeviceInfo.name) == 0)
+        return &gDeviceHooks;
+
+    return NULL;
+}
+
 
 void uninit_driver()
 {
-        TRACE("uninit_driver\n");
-        gLock.Delete();
-        put_module(VBOXGUEST_MODULE_NAME);
-}
-
-status_t device_open(const char* name, uint32 flags, void** cookie)
-{
-        TRACE("device_open\n");
-
-        if (!gCanHasDevice || strcmp(name, gDeviceInfo.name) != 0)
-                return B_BAD_VALUE;
-
-        // TODO init device!
-
-        *cookie = (void*)&gDeviceInfo;
-
-        return B_OK;
-}
-
-status_t device_close(void* dev)
-{
-        TRACE("device_close\n");
-        return B_ERROR;
-}
-
-status_t device_free(void* dev)
-{
-        TRACE("device_free\n");
-
-        DeviceInfo& di = *(DeviceInfo*)dev;
-        gLock.Acquire();
-
-        if (di.openCount <= 1) {
-                // TODO deinit device!
-
-                delete_area(di.sharedArea);
-                di.sharedArea = -1;
-                di.sharedInfo = NULL;
-        }
-
-        if (di.openCount > 0)
-                di.openCount--;
-
-        gLock.Release();
-
-        return B_OK;
-}
-
-status_t device_read(void* dev, off_t pos, void* buf, size_t* len)
-{
-        TRACE("device_read\n");
-        return B_NOT_ALLOWED;
-}
-
-status_t device_write(void* dev, off_t pos, const void* buf, size_t* len)
-{
-        TRACE("device_write\n");
-        return B_NOT_ALLOWED;
-}
-
-status_t device_ioctl(void* cookie, uint32 msg, void* buf, size_t len)
-{
-        TRACE("device_ioctl\n");
-
-        DeviceInfo* dev = (DeviceInfo*)cookie;
-
-        switch (msg) {
-        case B_GET_ACCELERANT_SIGNATURE:
-                strcpy((char*)buf, "vboxvideo.accelerant");
-                return B_OK;
-
-        case VBOXVIDEO_GET_PRIVATE_DATA:
-                return user_memcpy(buf, &dev->sharedArea, sizeof(area_id));
-
-        case VBOXVIDEO_GET_DEVICE_NAME:
-                if (user_strlcpy((char*)buf, gDeviceInfo.name, len) < B_OK)
-                        return B_BAD_ADDRESS;
-                else
-                        return B_OK;
-
-        case VBOXVIDEO_SET_DISPLAY_MODE: {
-                display_mode* mode = (display_mode*)buf;
-                VBoxVideoSetModeRegisters(mode->timing.h_display, mode->timing.v_display,
-                        mode->timing.h_display, get_depth_for_color_space(mode->space), 0, 0, 0);
-                gDeviceInfo.sharedInfo->currentMode = *mode;
-                return B_OK;
-        }
-        default:
-                return B_BAD_VALUE;
-        }
-
-}
+    TRACE("uninit_driver\n");
+    gLock.Delete();
+    put_module(VBOXGUEST_MODULE_NAME);
+}
+
+status_t device_open(const char *name, uint32 flags, void **cookie)
+{
+    TRACE("device_open\n");
+
+    if (!gCanHasDevice || strcmp(name, gDeviceInfo.name) != 0)
+        return B_BAD_VALUE;
+
+    // TODO init device!
+
+    *cookie = (void *)&gDeviceInfo;
+    return B_OK;
+}
+
+
+status_t device_close(void *dev)
+{
+    TRACE("device_close\n");
+    return B_ERROR;
+}
+
+
+status_t device_free(void *dev)
+{
+    TRACE("device_free\n");
+
+    DeviceInfo& di = *(DeviceInfo *)dev;
+    gLock.Acquire();
+
+    if (di.openCount <= 1)
+    {
+        // TODO deinit device!
+        delete_area(di.sharedArea);
+        di.sharedArea = -1;
+        di.sharedInfo = NULL;
+    }
+
+    if (di.openCount > 0)
+        di.openCount--;
+
+    gLock.Release();
+
+    return B_OK;
+}
+
+
+status_t device_read(void *dev, off_t pos, void *buf, size_t *len)
+{
+    TRACE("device_read\n");
+    return B_NOT_ALLOWED;
+}
+
+
+status_t device_write(void *dev, off_t pos, const void *buf, size_t *len)
+{
+    TRACE("device_write\n");
+    return B_NOT_ALLOWED;
+}
+
+
+status_t device_ioctl(void *cookie, uint32 msg, void *buf, size_t len)
+{
+    TRACE("device_ioctl\n");
+
+    DeviceInfo *dev = (DeviceInfo *)cookie;
+
+    switch (msg)
+    {
+        case B_GET_ACCELERANT_SIGNATURE:
+            strcpy((char *)buf, "vboxvideo.accelerant");
+            return B_OK;
+
+        case VBOXVIDEO_GET_PRIVATE_DATA:
+            return user_memcpy(buf, &dev->sharedArea, sizeof(area_id));
+
+        case VBOXVIDEO_GET_DEVICE_NAME:
+            if (user_strlcpy((char *)buf, gDeviceInfo.name, len) < B_OK)
+                return B_BAD_ADDRESS;
+            else
+                return B_OK;
+
+        case VBOXVIDEO_SET_DISPLAY_MODE:
+        {
+            display_mode *mode = (display_mode *)buf;
+            VBoxVideoSetModeRegisters(mode->timing.h_display, mode->timing.v_display,
+                                      mode->timing.h_display, get_depth_for_color_space(mode->space), 0, 0, 0);
+            gDeviceInfo.sharedInfo->currentMode = *mode;
+            return B_OK;
+        }
+        default:
+            return B_BAD_VALUE;
+    }
+
+}
+