Merge pull request #997 from birarda/assignment

file of static assignments for DS

CMakeLists.txt

@@ -20,4 +20,4 @@ add_subdirectory(interface)
 add_subdirectory(injector)
 add_subdirectory(pairing-server)
 add_subdirectory(space-server)
-add_subdirectory(voxel-edit)
+add_subdirectory(voxel-edit)

assignment-client/src/audio/AudioMixer.cpp

@@ -129,7 +129,7 @@ void AudioMixer::run() {
         // send a check in packet to the domain server if DOMAIN_SERVER_CHECK_IN_USECS has elapsed
         if (usecTimestampNow() - usecTimestamp(&lastDomainServerCheckIn) >= DOMAIN_SERVER_CHECK_IN_USECS) {
             gettimeofday(&lastDomainServerCheckIn, NULL);
-            NodeList::getInstance()->sendDomainServerCheckIn(this->getUUID().toRfc4122().constData());
+            NodeList::getInstance()->sendDomainServerCheckIn(_uuid.toRfc4122().constData());
             
             if (Logging::shouldSendStats() && numStatCollections > 0) {
                 // if we should be sending stats to Logstash send the appropriate average now

assignment-client/src/avatars/AvatarMixer.cpp

@@ -119,7 +119,7 @@ void AvatarMixer::run() {
         // send a check in packet to the domain server if DOMAIN_SERVER_CHECK_IN_USECS has elapsed
         if (usecTimestampNow() - usecTimestamp(&lastDomainServerCheckIn) >= DOMAIN_SERVER_CHECK_IN_USECS) {
             gettimeofday(&lastDomainServerCheckIn, NULL);
-            NodeList::getInstance()->sendDomainServerCheckIn(this->getUUID().toRfc4122().constData());
+            NodeList::getInstance()->sendDomainServerCheckIn(_uuid.toRfc4122().constData());
         }
         
         if (nodeList->getNodeSocket()->receive(nodeAddress, packetData, &receivedBytes) &&

domain-server/src/DomainServer.cpp

@@ -0,0 +1,598 @@
+//
+//  DomainServer.cpp
+//  hifi
+//
+//  Created by Stephen Birarda on 9/26/13.
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+
+#include <signal.h>
+
+#include <QStringList>
+
+#include <PacketHeaders.h>
+#include <SharedUtil.h>
+
+#include "DomainServer.h"
+
+DomainServer* DomainServer::domainServerInstance = NULL;
+
+void DomainServer::signalHandler(int signal) {
+    domainServerInstance->cleanup();
+    exit(1);
+}
+
+void DomainServer::setDomainServerInstance(DomainServer* domainServer) {
+    domainServerInstance = domainServer;
+}
+
+int DomainServer::civetwebRequestHandler(struct mg_connection *connection) {
+    const struct mg_request_info* ri = mg_get_request_info(connection);
+    
+    if (strcmp(ri->uri, "/assignment") == 0 && strcmp(ri->request_method, "POST") == 0) {
+        // return a 200
+        mg_printf(connection, "%s", "HTTP/1.0 200 OK\r\n\r\n");
+        // upload the file
+        mg_upload(connection, "/tmp");
+        
+        return 1;
+    } else {
+        // have mongoose process this request from the document_root
+        return 0;
+    }
+}
+
+const char ASSIGNMENT_SCRIPT_HOST_LOCATION[] = "resources/web/assignment";
+
+void DomainServer::civetwebUploadHandler(struct mg_connection *connection, const char *path) {
+    
+    // create an assignment for this saved script, for now make it local only
+    Assignment *scriptAssignment = new Assignment(Assignment::CreateCommand, Assignment::AgentType, Assignment::LocalLocation);
+    
+    // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
+    const char ASSIGNMENT_INSTANCES_HTTP_HEADER[] = "ASSIGNMENT-INSTANCES";
+    const char *requestInstancesHeader = mg_get_header(connection, ASSIGNMENT_INSTANCES_HTTP_HEADER);
+    
+    if (requestInstancesHeader) {
+        // the user has requested a number of instances greater than 1
+        // so set that on the created assignment
+        scriptAssignment->setNumberOfInstances(atoi(requestInstancesHeader));
+    }
+    
+    QString newPath(ASSIGNMENT_SCRIPT_HOST_LOCATION);
+    newPath += "/";
+    // append the UUID for this script as the new filename, remove the curly braces
+    newPath += scriptAssignment->getUUIDStringWithoutCurlyBraces();
+    
+    // rename the saved script to the GUID of the assignment and move it to the script host locaiton
+    rename(path, newPath.toLocal8Bit().constData());
+    
+    qDebug("Saved a script for assignment at %s\n", newPath.toLocal8Bit().constData());
+    
+    // add the script assigment to the assignment queue
+    // lock the assignment queue mutex since we're operating on a different thread than DS main
+    domainServerInstance->_assignmentQueueMutex.lock();
+    domainServerInstance->_assignmentQueue.push_back(scriptAssignment);
+    domainServerInstance->_assignmentQueueMutex.unlock();
+}
+
+void DomainServer::nodeAdded(Node* node) {
+    NodeList::getInstance()->increaseNodeID();
+}
+
+void DomainServer::nodeKilled(Node* node) {
+    // if this node has linked data it was from an assignment
+    if (node->getLinkedData()) {
+        Assignment* nodeAssignment =  (Assignment*) node->getLinkedData();
+        
+        qDebug() << "Adding assignment" << *nodeAssignment << " back to queue.\n";
+        
+        // find this assignment in the static file
+        for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
+            if (_staticAssignments[i].getUUID() == nodeAssignment->getUUID()) {
+                // reset the UUID on the static assignment
+                _staticAssignments[i].resetUUID();
+                
+                // put this assignment back in the queue so it goes out
+                _assignmentQueueMutex.lock();
+                _assignmentQueue.push_back(&_staticAssignments[i]);
+                _assignmentQueueMutex.unlock();
+                
+            } else if (_staticAssignments[i].getUUID().isNull()) {
+                // we are at the blank part of the static assignments - break out
+                break;
+            }
+        }
+    }
+    
+}
+
+unsigned char* DomainServer::addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd) {
+    *currentPosition++ = nodeToAdd->getType();
+    
+    currentPosition += packNodeId(currentPosition, nodeToAdd->getNodeID());
+    currentPosition += packSocket(currentPosition, nodeToAdd->getPublicSocket());
+    currentPosition += packSocket(currentPosition, nodeToAdd->getLocalSocket());
+    
+    // return the new unsigned char * for broadcast packet
+    return currentPosition;
+}
+
+DomainServer::DomainServer(int argc, char* argv[]) :
+    _assignmentQueueMutex(),
+    _assignmentQueue(),
+    _staticAssignmentFile(QString("%1/config.ds").arg(QCoreApplication::applicationDirPath())),
+    _staticAssignmentFileData(NULL),
+    _voxelServerConfig(NULL),
+    _hasCompletedRestartHold(false)
+{
+    DomainServer::setDomainServerInstance(this);
+        
+    const char CUSTOM_PORT_OPTION[] = "-p";
+    const char* customPortString = getCmdOption(argc, (const char**) argv, CUSTOM_PORT_OPTION);
+    unsigned short domainServerPort = customPortString ? atoi(customPortString) : DEFAULT_DOMAIN_SERVER_PORT;
+    
+    NodeList::createInstance(NODE_TYPE_DOMAIN, domainServerPort);
+    
+    struct sigaction sigIntHandler;
+    
+    sigIntHandler.sa_handler = DomainServer::signalHandler;
+    sigemptyset(&sigIntHandler.sa_mask);
+    sigIntHandler.sa_flags = 0;
+    
+    sigaction(SIGINT, &sigIntHandler, NULL);
+        
+    const char VOXEL_CONFIG_OPTION[] = "--voxelServerConfig";
+    _voxelServerConfig = getCmdOption(argc, (const char**) argv, VOXEL_CONFIG_OPTION);
+    
+    // setup the mongoose web server
+    struct mg_callbacks callbacks = {};
+    
+    QString documentRoot = QString("%1/resources/web").arg(QCoreApplication::applicationDirPath());
+    
+    // list of options. Last element must be NULL.
+    const char* options[] = {"listening_ports", "8080",
+        "document_root", documentRoot.toLocal8Bit().constData(), NULL};
+    
+    callbacks.begin_request = civetwebRequestHandler;
+    callbacks.upload = civetwebUploadHandler;
+    
+    // Start the web server.
+    mg_start(&callbacks, NULL, options);
+}
+
+void DomainServer::prepopulateStaticAssignmentFile() {
+    int numFreshStaticAssignments = 0;
+    
+    // write a fresh static assignment array to file
+    
+    Assignment freshStaticAssignments[MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS];
+    
+    // pre-populate the first static assignment list with assignments for root AuM, AvM, VS
+    freshStaticAssignments[numFreshStaticAssignments++] = Assignment(Assignment::CreateCommand,
+                                           Assignment::AudioMixerType,
+                                           Assignment::LocalLocation);
+    freshStaticAssignments[numFreshStaticAssignments++] = Assignment(Assignment::CreateCommand,
+                                           Assignment::AvatarMixerType,
+                                           Assignment::LocalLocation);
+    
+    // Handle Domain/Voxel Server configuration command line arguments
+    if (_voxelServerConfig) {
+        qDebug("Reading Voxel Server Configuration.\n");
+        qDebug() << "config: " << _voxelServerConfig << "\n";
+        
+        QString multiConfig((const char*) _voxelServerConfig);
+        QStringList multiConfigList = multiConfig.split(";");
+        
+        // read each config to a payload for a VS assignment
+        for (int i = 0; i < multiConfigList.size(); i++) {
+            QString config = multiConfigList.at(i);
+            
+            qDebug("config[%d]=%s\n", i, config.toLocal8Bit().constData());
+            
+            Assignment voxelServerAssignment(Assignment::CreateCommand,
+                                             Assignment::VoxelServerType,
+                                             Assignment::LocalLocation); // use same location as we were created in.
+            
+            int payloadLength = config.length() + sizeof(char);
+            voxelServerAssignment.setPayload((uchar*)config.toLocal8Bit().constData(), payloadLength);
+            
+            freshStaticAssignments[numFreshStaticAssignments++] = voxelServerAssignment;
+        }
+    } else {
+        Assignment rootVoxelServerAssignment(Assignment::CreateCommand,
+                                             Assignment::VoxelServerType,
+                                             Assignment::LocalLocation);
+        freshStaticAssignments[numFreshStaticAssignments++] = rootVoxelServerAssignment;
+    }
+    
+    qDebug() << "Adding" << numFreshStaticAssignments << "static assignments to fresh file.\n";
+    
+    _staticAssignmentFile.open(QIODevice::WriteOnly);
+    _staticAssignmentFile.write((char*) &freshStaticAssignments, sizeof(freshStaticAssignments));
+    _staticAssignmentFile.resize(MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS * sizeof(Assignment));
+    _staticAssignmentFile.close();
+}
+
+Assignment* DomainServer::matchingStaticAssignmentForCheckIn(NODE_TYPE nodeType, const uchar* checkInData) {
+    // pull the UUID passed with the check in
+    QUuid checkInUUID = QUuid::fromRfc4122(QByteArray((const char*) checkInData + numBytesForPacketHeader(checkInData) +
+                                                      sizeof(NODE_TYPE),
+                                                      NUM_BYTES_RFC4122_UUID));
+    
+    if (_hasCompletedRestartHold) {
+        _assignmentQueueMutex.lock();
+        
+        // iterate the assignment queue to check for a match
+        std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
+        while (assignment != _assignmentQueue.end()) {
+            if ((*assignment)->getUUID() == checkInUUID) {
+                // return the matched assignment
+                _assignmentQueueMutex.unlock();
+                return *assignment;
+            } else {
+                // no match, push deque iterator forwards
+                assignment++;
+            }
+        }
+        
+        _assignmentQueueMutex.unlock();
+    } else {
+        for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
+            if (_staticAssignments[i].getUUID() == checkInUUID) {
+                // return matched assignment
+                return &_staticAssignments[i];
+            } else if (_staticAssignments[i].getUUID().isNull()) {
+                // end of static assignments, no match - return NULL
+                return NULL;
+            }
+        }
+    }
+    
+    return NULL;
+}
+
+Assignment* DomainServer::deployableAssignmentForRequest(Assignment& requestAssignment) {
+    _assignmentQueueMutex.lock();
+    
+    // this is an unassigned client talking to us directly for an assignment
+    // go through our queue and see if there are any assignments to give out
+    std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
+    
+    while (assignment != _assignmentQueue.end()) {
+        
+        if (requestAssignment.getType() == Assignment::AllTypes ||
+            (*assignment)->getType() == requestAssignment.getType()) {
+            
+            Assignment* deployableAssignment = *assignment;
+            
+            if ((*assignment)->getType() == Assignment::AgentType) {
+                // if this is a script assignment we need to delete it to avoid a memory leak
+                // or if there is more than one instance to send out, simpy decrease the number of instances
+                if ((*assignment)->getNumberOfInstances() > 1) {
+                    (*assignment)->decrementNumberOfInstances();
+                } else {
+                    _assignmentQueue.erase(assignment);
+                    delete *assignment;
+                }
+            } else {
+                // remove the assignment from the queue
+                _assignmentQueue.erase(assignment);
+                
+                // until we get a check-in from that GUID
+                // put assignment back in queue but stick it at the back so the others have a chance to go out
+                _assignmentQueue.push_back(deployableAssignment);
+            }
+            
+            // stop looping, we've handed out an assignment
+            _assignmentQueueMutex.unlock();
+            return deployableAssignment;
+        } else {
+            // push forward the iterator to check the next assignment
+            assignment++;
+        }
+    }
+    
+    _assignmentQueueMutex.unlock();
+    return NULL;
+}
+
+void DomainServer::removeAssignmentFromQueue(Assignment* removableAssignment) {
+    
+    _assignmentQueueMutex.lock();
+    
+    std::deque<Assignment*>::iterator assignment = _assignmentQueue.begin();
+    
+    while (assignment != _assignmentQueue.end()) {
+        if ((*assignment)->getUUID() == removableAssignment->getUUID()) {
+            _assignmentQueue.erase(assignment);
+            break;
+        } else {
+            // push forward the iterator to check the next assignment
+            assignment++;
+        }
+    }
+    
+    _assignmentQueueMutex.unlock();
+}
+
+bool DomainServer::checkInWithUUIDMatchesExistingNode(sockaddr* nodePublicSocket,
+                                                      sockaddr* nodeLocalSocket,
+                                                      const uchar* checkInData) {
+    // pull the UUID passed with the check in
+    QUuid checkInUUID = QUuid::fromRfc4122(QByteArray((const char*) checkInData + numBytesForPacketHeader(checkInData) +
+                                                      sizeof(NODE_TYPE),
+                                                      NUM_BYTES_RFC4122_UUID));
+    
+    NodeList* nodeList = NodeList::getInstance();
+    
+    for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
+        if (node->getLinkedData()
+            && socketMatch(node->getPublicSocket(), nodePublicSocket)
+            && socketMatch(node->getLocalSocket(), nodeLocalSocket)
+            && ((Assignment*) node->getLinkedData())->getUUID() == checkInUUID) {
+            // this is a matching existing node if the public socket, local socket, and UUID match
+            return true;
+        }
+    }
+    
+    return false;
+}
+
+void DomainServer::cleanup() {
+    _staticAssignmentFile.unmap(_staticAssignmentFileData);
+    _staticAssignmentFile.close();
+}
+
+int DomainServer::run() {
+    NodeList* nodeList = NodeList::getInstance();
+    
+    nodeList->addHook(this);
+    
+    ssize_t receivedBytes = 0;
+    char nodeType = '\0';
+    
+    unsigned char broadcastPacket[MAX_PACKET_SIZE];
+    unsigned char packetData[MAX_PACKET_SIZE];
+    
+    unsigned char* currentBufferPos;
+    unsigned char* startPointer;
+    
+    sockaddr_in nodePublicAddress, nodeLocalAddress, replyDestinationSocket;
+    nodeLocalAddress.sin_family = AF_INET;
+    
+    in_addr_t serverLocalAddress = getLocalAddress();
+    
+    nodeList->startSilentNodeRemovalThread();
+    
+    if (!_staticAssignmentFile.exists() || _voxelServerConfig) {
+        
+        if (_voxelServerConfig) {
+            // we have a new VS config, clear the existing file to start fresh
+            _staticAssignmentFile.remove();
+        }
+        
+        prepopulateStaticAssignmentFile();
+    }
+    
+    _staticAssignmentFile.open(QIODevice::ReadWrite);
+    
+    _staticAssignmentFileData = _staticAssignmentFile.map(0, _staticAssignmentFile.size());
+    
+    _staticAssignments = (Assignment*) _staticAssignmentFileData;
+    
+    timeval startTime;
+    gettimeofday(&startTime, NULL);
+    
+    while (true) {
+        while (nodeList->getNodeSocket()->receive((sockaddr *)&nodePublicAddress, packetData, &receivedBytes) &&
+               packetVersionMatch(packetData)) {
+            if (packetData[0] == PACKET_TYPE_DOMAIN_REPORT_FOR_DUTY || packetData[0] == PACKET_TYPE_DOMAIN_LIST_REQUEST) {
+                // this is an RFD or domain list request packet, and there is a version match
+                
+                int numBytesSenderHeader = numBytesForPacketHeader(packetData);
+                
+                nodeType = *(packetData + numBytesSenderHeader);
+                int numBytesSocket = unpackSocket(packetData + numBytesSenderHeader + sizeof(NODE_TYPE),
+                                                  (sockaddr*) &nodeLocalAddress);
+                
+                replyDestinationSocket = nodePublicAddress;
+                
+                // check the node public address
+                // if it matches our local address
+                // or if it's the loopback address we're on the same box
+                if (nodePublicAddress.sin_addr.s_addr == serverLocalAddress ||
+                    nodePublicAddress.sin_addr.s_addr == htonl(INADDR_LOOPBACK)) {
+                    
+                    nodePublicAddress.sin_addr.s_addr = 0;
+                }
+                
+                const char STATICALLY_ASSIGNED_NODES[3] = {
+                    NODE_TYPE_AUDIO_MIXER,
+                    NODE_TYPE_AVATAR_MIXER,
+                    NODE_TYPE_VOXEL_SERVER
+                };
+                
+                Assignment* matchingStaticAssignment = NULL;
+                
+                if (memchr(STATICALLY_ASSIGNED_NODES, nodeType, sizeof(STATICALLY_ASSIGNED_NODES)) == NULL ||
+                    ((matchingStaticAssignment = matchingStaticAssignmentForCheckIn(nodeType, packetData)) ||
+                     checkInWithUUIDMatchesExistingNode((sockaddr*) &nodePublicAddress,
+                                                        (sockaddr*) &nodeLocalAddress,
+                                                        packetData))) {
+                    
+                    Node* checkInNode = nodeList->addOrUpdateNode((sockaddr*) &nodePublicAddress,
+                                                                  (sockaddr*) &nodeLocalAddress,
+                                                                  nodeType,
+                                                                  nodeList->getLastNodeID());
+                    
+                    if (matchingStaticAssignment) {
+                        // this was a newly added node with a matching static assignment
+                        
+                        if (_hasCompletedRestartHold) {
+                            // remove the matching assignment from the assignment queue so we don't take the next check in
+                            removeAssignmentFromQueue(matchingStaticAssignment);
+                        }
+                        
+                        // set the linked data for this node to a copy of the matching assignment
+                        // so we can re-queue it should the node die
+                        Assignment* nodeCopyOfMatchingAssignment = new Assignment(*matchingStaticAssignment);
+                
+                        checkInNode->setLinkedData(nodeCopyOfMatchingAssignment);
+                    }
+                    
+                    int numHeaderBytes = populateTypeAndVersion(broadcastPacket, PACKET_TYPE_DOMAIN);
+                    
+                    currentBufferPos = broadcastPacket + numHeaderBytes;
+                    startPointer = currentBufferPos;
+                    
+                    int numBytesUUID = (nodeType == NODE_TYPE_AUDIO_MIXER || nodeType == NODE_TYPE_AVATAR_MIXER)
+                        ? NUM_BYTES_RFC4122_UUID
+                        : 0;
+                    
+                    unsigned char* nodeTypesOfInterest = packetData + numBytesSenderHeader + numBytesUUID +
+                    sizeof(NODE_TYPE) + numBytesSocket + sizeof(unsigned char);
+                    int numInterestTypes = *(nodeTypesOfInterest - 1);
+                    
+                    if (numInterestTypes > 0) {
+                        // if the node has sent no types of interest, assume they want nothing but their own ID back
+                        for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
+                            if (!node->matches((sockaddr*) &nodePublicAddress, (sockaddr*) &nodeLocalAddress, nodeType) &&
+                                memchr(nodeTypesOfInterest, node->getType(), numInterestTypes)) {
+                                
+                                // don't send avatar nodes to other avatars, that will come from avatar mixer
+                                if (nodeType != NODE_TYPE_AGENT || node->getType() != NODE_TYPE_AGENT) {
+                                    currentBufferPos = addNodeToBroadcastPacket(currentBufferPos, &(*node));
+                                }
+                                
+                            }
+                        }
+                    }
+                    
+                    // update last receive to now
+                    uint64_t timeNow = usecTimestampNow();
+                    checkInNode->setLastHeardMicrostamp(timeNow);
+                    
+                    // add the node ID to the end of the pointer
+                    currentBufferPos += packNodeId(currentBufferPos, checkInNode->getNodeID());
+                    
+                    // send the constructed list back to this node
+                    nodeList->getNodeSocket()->send((sockaddr*)&replyDestinationSocket,
+                                                    broadcastPacket,
+                                                    (currentBufferPos - startPointer) + numHeaderBytes);
+                }
+            } else if (packetData[0] == PACKET_TYPE_REQUEST_ASSIGNMENT) {
+                
+                qDebug("Received a request for assignment.\n");
+                
+                if (_assignmentQueue.size() > 0) {
+                    // construct the requested assignment from the packet data
+                    Assignment requestAssignment(packetData, receivedBytes);
+                    
+                    Assignment* assignmentToDeploy = deployableAssignmentForRequest(requestAssignment);
+                    
+                    if (assignmentToDeploy) {
+                        
+                        // give this assignment out, either the type matches or the requestor said they will take any
+                        int numHeaderBytes = populateTypeAndVersion(broadcastPacket, PACKET_TYPE_CREATE_ASSIGNMENT);
+                        int numAssignmentBytes = assignmentToDeploy->packToBuffer(broadcastPacket + numHeaderBytes);
+        
+                        nodeList->getNodeSocket()->send((sockaddr*) &nodePublicAddress,
+                                                        broadcastPacket,
+                                                        numHeaderBytes + numAssignmentBytes);
+                    }
+                    
+                }
+            } else if (packetData[0] == PACKET_TYPE_CREATE_ASSIGNMENT) {
+                // this is a create assignment likely recieved from a server needed more clients to help with load
+                
+                // unpack it
+                Assignment* createAssignment = new Assignment(packetData, receivedBytes);
+                
+                qDebug() << "Received a create assignment -" << *createAssignment << "\n";
+                
+                // check the node public address
+                // if it matches our local address
+                // or if it's the loopback address we're on the same box
+                if (nodePublicAddress.sin_addr.s_addr == serverLocalAddress ||
+                    nodePublicAddress.sin_addr.s_addr == htonl(INADDR_LOOPBACK)) {
+                    
+                    nodePublicAddress.sin_addr.s_addr = 0;
+                }
+                
+                // make sure we have a matching node with the UUID packed with the assignment
+                // if the node has sent no types of interest, assume they want nothing but their own ID back
+                for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
+                    if (node->getLinkedData()
+                        && socketMatch((sockaddr*) &nodePublicAddress, node->getPublicSocket())
+                        && ((Assignment*) node->getLinkedData())->getUUID() == createAssignment->getUUID()) {
+                        
+                        // give the create assignment a new UUID
+                        createAssignment->resetUUID();
+                        
+                        // add the assignment at the back of the queue
+                        _assignmentQueueMutex.lock();
+                        _assignmentQueue.push_back(createAssignment);
+                        _assignmentQueueMutex.unlock();
+                        
+                        // find the first available spot in the static assignments and put this assignment there
+                        for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
+                            if (_staticAssignments[i].getUUID().isNull()) {
+                                _staticAssignments[i] = *createAssignment;
+                                
+                                // we've stuck the assignment in, break out
+                                break;
+                            }
+                        }
+                        
+                        // we found the matching node that asked for create assignment, break out
+                        break;
+                    }
+                }
+            }
+        }
+        
+        const long long RESTART_HOLD_TIME_USECS = 5 * 1000 * 1000;
+        
+        if (!_hasCompletedRestartHold && usecTimestampNow() - usecTimestamp(&startTime) > RESTART_HOLD_TIME_USECS) {
+            _hasCompletedRestartHold = true;
+            
+            // pull anything in the static assignment file that isn't spoken for and add to the assignment queue
+            for (int i = 0; i < MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS; i++) {
+                if (_staticAssignments[i].getUUID().isNull()) {
+                    // reached the end of static assignments, bail
+                    break;
+                }
+                
+                bool foundMatchingAssignment = false;
+                
+                // enumerate the nodes and check if there is one with an attached assignment with matching UUID
+                // if the node has sent no types of interest, assume they want nothing but their own ID back
+                for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
+                    if (node->getLinkedData()) {
+                        Assignment* linkedAssignment = (Assignment*) node->getLinkedData();
+                        if (linkedAssignment->getUUID() == _staticAssignments[i].getUUID()) {
+                            foundMatchingAssignment = true;
+                            break;
+                        }
+                    }
+                }
+                
+                if (!foundMatchingAssignment) {
+                    // this assignment has not been fulfilled - reset the UUID and add it to the assignment queue
+                    _staticAssignments[i].resetUUID();
+                    
+                    qDebug() << "Adding static assignment to queue -" << _staticAssignments[i] << "\n";
+                    
+                    _assignmentQueueMutex.lock();
+                    _assignmentQueue.push_back(&_staticAssignments[i]);
+                    _assignmentQueueMutex.unlock();
+                }
+            }
+        }
+    }
+    
+    this->cleanup();
+    
+    return 0;
+}

domain-server/src/DomainServer.h

@@ -0,0 +1,67 @@
+//
+//  DomainServer.h
+//  hifi
+//
+//  Created by Stephen Birarda on 9/26/13.
+//  Copyright (c) 2013 HighFidelity, Inc. All rights reserved.
+//
+
+#ifndef __hifi__DomainServer__
+#define __hifi__DomainServer__
+
+#include <deque>
+
+#include <QtCore/QCoreApplication>
+#include <QtCore/QFile>
+#include <QtCore/QMutex>
+
+#include <Assignment.h>
+#include <NodeList.h>
+
+#include <civetweb.h>
+
+const int MAX_STATIC_ASSIGNMENT_FILE_ASSIGNMENTS = 1000;
+
+class DomainServer : public NodeListHook {
+public:
+    DomainServer(int argc, char* argv[]);
+    
+    int run();
+    
+    static void signalHandler(int signal);
+    static void setDomainServerInstance(DomainServer* domainServer);
+    
+    /// Called by NodeList to inform us that a node has been added.
+    void nodeAdded(Node* node);
+    /// Called by NodeList to inform us that a node has been killed.
+    void nodeKilled(Node* node);
+private:
+    static int civetwebRequestHandler(struct mg_connection *connection);
+    static void civetwebUploadHandler(struct mg_connection *connection, const char *path);
+    
+    static DomainServer* domainServerInstance;
+    
+    void prepopulateStaticAssignmentFile();
+    Assignment* matchingStaticAssignmentForCheckIn(NODE_TYPE nodeType, const uchar* checkInUUID);
+    Assignment* deployableAssignmentForRequest(Assignment& requestAssignment);
+    void removeAssignmentFromQueue(Assignment* removableAssignment);
+    bool checkInWithUUIDMatchesExistingNode(sockaddr* nodePublicSocket, sockaddr* nodeLocalSocket, const uchar* checkInData);
+    
+    void cleanup();
+    
+    unsigned char* addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd);
+    
+    QMutex _assignmentQueueMutex;
+    std::deque<Assignment*> _assignmentQueue;
+    
+    QFile _staticAssignmentFile;
+    uchar* _staticAssignmentFileData;
+    
+    Assignment* _staticAssignments;
+    
+    const char* _voxelServerConfig;
+    
+    bool _hasCompletedRestartHold;
+};
+
+#endif /* defined(__hifi__DomainServer__) */

domain-server/src/main.cpp

@@ -11,429 +11,22 @@
 //  The connection is stateless... the domain server will set you inactive if it does not hear from
 //  you in LOGOFF_CHECK_INTERVAL milliseconds, meaning your info will not be sent to other users.
 //
-//  Each packet from an node has as first character the type of server:
-//
-//  I - Interactive Node
-//  M - Audio Mixer
-//
-
-#include <arpa/inet.h>
-#include <fcntl.h>
-#include <deque>
-#include <map>
-#include <math.h>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
 
 #include <QtCore/QCoreApplication>
-#include <QtCore/QMap>
-#include <QtCore/QMutex>
 
-#include <civetweb.h>
+#include <Logging.h>
 
-#include "Assignment.h"
-#include "NodeList.h"
-#include "NodeTypes.h"
-#include "Logging.h"
-#include "PacketHeaders.h"
-#include "SharedUtil.h"
+#include "DomainServer.h"
 
-const int DOMAIN_LISTEN_PORT = 40102;
-unsigned char packetData[MAX_PACKET_SIZE];
-
-const int NODE_COUNT_STAT_INTERVAL_MSECS = 5000;
-
-QMutex assignmentQueueMutex;
-std::deque<Assignment*> assignmentQueue;
-
-unsigned char* addNodeToBroadcastPacket(unsigned char* currentPosition, Node* nodeToAdd) {
-    *currentPosition++ = nodeToAdd->getType();
+int main(int argc, char* argv[]) {
     
-    currentPosition += packNodeId(currentPosition, nodeToAdd->getNodeID());
-    currentPosition += packSocket(currentPosition, nodeToAdd->getPublicSocket());
-    currentPosition += packSocket(currentPosition, nodeToAdd->getLocalSocket());
-    
-    // return the new unsigned char * for broadcast packet
-    return currentPosition;
-}
-
-static int mongooseRequestHandler(struct mg_connection *conn) {
-    const struct mg_request_info* ri = mg_get_request_info(conn);
-    
-    if (strcmp(ri->uri, "/assignment") == 0 && strcmp(ri->request_method, "POST") == 0) {
-        // return a 200
-        mg_printf(conn, "%s", "HTTP/1.0 200 OK\r\n\r\n");
-        // upload the file
-        mg_upload(conn, "/tmp");
-        
-        return 1;
-    } else {
-        // have mongoose process this request from the document_root
-        return 0;
-    }
-}
-
-const char ASSIGNMENT_SCRIPT_HOST_LOCATION[] = "resources/web/assignment";
-
-static void mongooseUploadHandler(struct mg_connection *conn, const char *path) {
-    
-    // create an assignment for this saved script, for now make it local only
-    Assignment *scriptAssignment = new Assignment(Assignment::CreateCommand, Assignment::AgentType, Assignment::LocalLocation);
-    
-    // check how many instances of this assignment the user wants by checking the ASSIGNMENT-INSTANCES header
-    const char ASSIGNMENT_INSTANCES_HTTP_HEADER[] = "ASSIGNMENT-INSTANCES";
-    const char *requestInstancesHeader = mg_get_header(conn, ASSIGNMENT_INSTANCES_HTTP_HEADER);
-    
-    if (requestInstancesHeader) {
-        // the user has requested a number of instances greater than 1
-        // so set that on the created assignment
-        scriptAssignment->setNumberOfInstances(atoi(requestInstancesHeader));
-    }
-    
-    QString newPath(ASSIGNMENT_SCRIPT_HOST_LOCATION);
-    newPath += "/";
-    // append the UUID for this script as the new filename, remove the curly braces
-    newPath += scriptAssignment->getUUIDStringWithoutCurlyBraces();
-    
-    // rename the saved script to the GUID of the assignment and move it to the script host locaiton
-    rename(path, newPath.toStdString().c_str());
-
-    qDebug("Saved a script for assignment at %s\n", newPath.toStdString().c_str());
-    
-    // add the script assigment to the assignment queue
-    // lock the assignment queue mutex since we're operating on a different thread than DS main
-    ::assignmentQueueMutex.lock();
-    ::assignmentQueue.push_back(scriptAssignment);
-    ::assignmentQueueMutex.unlock();
-}
-
-int main(int argc, const char* argv[]) {
-    
-    QCoreApplication domainServer(argc, (char**) argv);
+    setvbuf(stdout, NULL, _IOLBF, 0);
     
     qInstallMessageHandler(Logging::verboseMessageHandler);
     
-    const char CUSTOM_PORT_OPTION[] = "-p";
-    const char* customPortString = getCmdOption(argc, argv, CUSTOM_PORT_OPTION);
-    unsigned short domainServerPort = customPortString ? atoi(customPortString) : DOMAIN_LISTEN_PORT;
+    QCoreApplication application(argc, argv);
+    DomainServer domainServer(argc, argv);
     
-    NodeList* nodeList = NodeList::createInstance(NODE_TYPE_DOMAIN, domainServerPort);
-
-    setvbuf(stdout, NULL, _IOLBF, 0);
-    
-    ssize_t receivedBytes = 0;
-    char nodeType = '\0';
-    
-    unsigned char broadcastPacket[MAX_PACKET_SIZE];
-    
-    unsigned char* currentBufferPos;
-    unsigned char* startPointer;
-    
-    sockaddr_in nodePublicAddress, nodeLocalAddress, replyDestinationSocket;
-    nodeLocalAddress.sin_family = AF_INET;
-    
-    in_addr_t serverLocalAddress = getLocalAddress();
-    
-    nodeList->startSilentNodeRemovalThread();
-
-    timeval lastStatSendTime = {};
-    
-    // as a domain-server we will always want an audio mixer and avatar mixer
-    // setup the create assignments for those
-    Assignment audioMixerAssignment(Assignment::CreateCommand,
-                                    Assignment::AudioMixerType,
-                                    Assignment::LocalLocation);
-    
-    Assignment avatarMixerAssignment(Assignment::CreateCommand,
-                                     Assignment::AvatarMixerType,
-                                     Assignment::LocalLocation);
-    
-    Assignment voxelServerAssignment(Assignment::CreateCommand,
-                                     Assignment::VoxelServerType,
-                                     Assignment::LocalLocation);
-
-    // Handle Domain/Voxel Server configuration command line arguments
-    const char VOXEL_CONFIG_OPTION[] = "--voxelServerConfig";
-    const char* voxelServerConfig = getCmdOption(argc, argv, VOXEL_CONFIG_OPTION);
-    if (voxelServerConfig) {
-        qDebug("Reading Voxel Server Configuration.\n");
-        qDebug() << "   config: " << voxelServerConfig << "\n";
-        int payloadLength = strlen(voxelServerConfig) + sizeof(char);
-        voxelServerAssignment.setPayload((const uchar*)voxelServerConfig, payloadLength);
-    }
-    
-    // construct a local socket to send with our created assignments to the global AS
-    sockaddr_in localSocket = {};
-    localSocket.sin_family = AF_INET;
-    localSocket.sin_port = htons(nodeList->getInstance()->getNodeSocket()->getListeningPort());
-    localSocket.sin_addr.s_addr = serverLocalAddress;
-    
-    // setup the mongoose web server
-    struct mg_context* ctx;
-    struct mg_callbacks callbacks = {};
-    
-    QString documentRoot = QString("%1/resources/web").arg(QCoreApplication::applicationDirPath());
-    
-    // list of options. Last element must be NULL.
-    const char* options[] = {"listening_ports", "8080",
-                             "document_root", documentRoot.toStdString().c_str(), NULL};
-    
-    callbacks.begin_request = mongooseRequestHandler;
-    callbacks.upload = mongooseUploadHandler;
-    
-    // Start the web server.
-    ctx = mg_start(&callbacks, NULL, options);
-    
-    while (true) {
-        
-        ::assignmentQueueMutex.lock();
-        // check if our audio-mixer or avatar-mixer are dead and we don't have existing assignments in the queue
-        // so we can add those assignments back to the front of the queue since they are high-priority
-        if (!nodeList->soloNodeOfType(NODE_TYPE_AVATAR_MIXER) &&
-            std::find(::assignmentQueue.begin(), assignmentQueue.end(), &avatarMixerAssignment) == ::assignmentQueue.end()) {
-            qDebug("Missing an avatar mixer and assignment not in queue. Adding.\n");
-            
-            // reset the UUID so it is new
-            avatarMixerAssignment.resetUUID();
-            
-            ::assignmentQueue.push_front(&avatarMixerAssignment);
-        }
-        
-        if (!nodeList->soloNodeOfType(NODE_TYPE_AUDIO_MIXER) &&
-            std::find(::assignmentQueue.begin(), ::assignmentQueue.end(), &audioMixerAssignment) == ::assignmentQueue.end()) {
-            qDebug("Missing an audio mixer and assignment not in queue. Adding.\n");
-            
-            // reset the UUID so it is new
-            audioMixerAssignment.resetUUID();
-            
-            ::assignmentQueue.push_front(&audioMixerAssignment);
-        }
-
-        // Now handle voxel servers. Since Voxel Servers aren't soloNodeOfType() we will count them and add an assignment if
-        // there is not at least one of them in the domain.
-        int voxelServerCount = 0;
-        for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
-            if (node->getType() == NODE_TYPE_VOXEL_SERVER) {
-                voxelServerCount++;
-            }
-        }
-        if (voxelServerCount == 0 &&
-            std::find(::assignmentQueue.begin(), ::assignmentQueue.end(), &voxelServerAssignment) == ::assignmentQueue.end()) {
-            qDebug("Missing a voxel server and assignment not in queue. Adding.\n");
-            ::assignmentQueue.push_front(&voxelServerAssignment);
-        }
-
-        ::assignmentQueueMutex.unlock();
-        
-        while (nodeList->getNodeSocket()->receive((sockaddr *)&nodePublicAddress, packetData, &receivedBytes) &&
-               packetVersionMatch(packetData)) {
-            if (packetData[0] == PACKET_TYPE_DOMAIN_REPORT_FOR_DUTY || packetData[0] == PACKET_TYPE_DOMAIN_LIST_REQUEST) {
-                // this is an RFD or domain list request packet, and there is a version match
-                std::map<char, Node *> newestSoloNodes;
-                
-                int numBytesSenderHeader = numBytesForPacketHeader(packetData);
-                
-                nodeType = *(packetData + numBytesSenderHeader);
-                int numBytesSocket = unpackSocket(packetData + numBytesSenderHeader + sizeof(NODE_TYPE),
-                                                  (sockaddr*) &nodeLocalAddress);
-                
-                replyDestinationSocket = nodePublicAddress;
-                
-                // check the node public address
-                // if it matches our local address
-                // or if it's the loopback address we're on the same box
-                if (nodePublicAddress.sin_addr.s_addr == serverLocalAddress ||
-                    nodePublicAddress.sin_addr.s_addr == htonl(INADDR_LOOPBACK)) {
-                    
-                    nodePublicAddress.sin_addr.s_addr = 0;
-                }
-                
-                bool matchedUUID = true;
-                
-                if ((nodeType == NODE_TYPE_AVATAR_MIXER || nodeType == NODE_TYPE_AUDIO_MIXER) &&
-                    !nodeList->soloNodeOfType(nodeType)) {
-                    // if this is an audio-mixer or an avatar-mixer and we don't have one yet
-                    // we need to check the GUID of the assignment in the queue
-                    // (if it exists) to make sure there is a match
-                    
-                    // reset matchedUUID to false so there is no match by default
-                    matchedUUID = false;
-                    
-                    // pull the UUID passed with the check in
-                    QUuid checkInUUID = QUuid::fromRfc4122(QByteArray((const char*) packetData + numBytesSenderHeader +
-                                                                      sizeof(NODE_TYPE),
-                                                                      NUM_BYTES_RFC4122_UUID));
-                    
-                    // lock the assignment queue
-                    ::assignmentQueueMutex.lock();
-                    
-                    std::deque<Assignment*>::iterator assignment = ::assignmentQueue.begin();
-                    
-                    Assignment::Type matchType = nodeType == NODE_TYPE_AUDIO_MIXER
-                        ? Assignment::AudioMixerType : Assignment::AvatarMixerType;
-                    
-                    // enumerate the assignments and see if there is a type and UUID match
-                    while (assignment != ::assignmentQueue.end()) {
-                        
-                        if ((*assignment)->getType() == matchType
-                            && (*assignment)->getUUID() == checkInUUID) {
-                            // type and UUID match
-                            matchedUUID = true;
-                            
-                            // remove this assignment from the queue
-                            ::assignmentQueue.erase(assignment);
-                            
-                            break;
-                        } else {
-                            // no match, keep looking
-                            assignment++;
-                        }
-                    }
-                    
-                    // unlock the assignment queue
-                    ::assignmentQueueMutex.unlock();
-                }
-                
-                if (matchedUUID) {
-                    Node* newNode = nodeList->addOrUpdateNode((sockaddr*) &nodePublicAddress,
-                                                              (sockaddr*) &nodeLocalAddress,
-                                                              nodeType,
-                                                              nodeList->getLastNodeID());
-                    
-                    // if addOrUpdateNode returns NULL this was a solo node we already have, don't talk back to it
-                    if (newNode) {
-                        if (newNode->getNodeID() == nodeList->getLastNodeID()) {
-                            nodeList->increaseNodeID();
-                        }
-                        
-                        int numHeaderBytes = populateTypeAndVersion(broadcastPacket, PACKET_TYPE_DOMAIN);
-                        
-                        currentBufferPos = broadcastPacket + numHeaderBytes;
-                        startPointer = currentBufferPos;
-                        
-                        int numBytesUUID = (nodeType == NODE_TYPE_AUDIO_MIXER || nodeType == NODE_TYPE_AVATAR_MIXER)
-                            ? NUM_BYTES_RFC4122_UUID
-                            : 0;
-                        
-                        unsigned char* nodeTypesOfInterest = packetData + numBytesSenderHeader + numBytesUUID +
-                            sizeof(NODE_TYPE) + numBytesSocket + sizeof(unsigned char);
-                        int numInterestTypes = *(nodeTypesOfInterest - 1);
-                        
-                        if (numInterestTypes > 0) {
-                            // if the node has sent no types of interest, assume they want nothing but their own ID back
-                            for (NodeList::iterator node = nodeList->begin(); node != nodeList->end(); node++) {
-                                if (!node->matches((sockaddr*) &nodePublicAddress, (sockaddr*) &nodeLocalAddress, nodeType) &&
-                                    memchr(nodeTypesOfInterest, node->getType(), numInterestTypes)) {
-                
-                                    // don't send avatar nodes to other avatars, that will come from avatar mixer
-                                    if (nodeType != NODE_TYPE_AGENT || node->getType() != NODE_TYPE_AGENT) {
-                                        currentBufferPos = addNodeToBroadcastPacket(currentBufferPos, &(*node));
-                                    }
-                                    
-                                }
-                            }
-                            
-                            
-                        }
-                        
-                        // update last receive to now
-                        uint64_t timeNow = usecTimestampNow();
-                        newNode->setLastHeardMicrostamp(timeNow);
-                        
-                        // add the node ID to the end of the pointer
-                        currentBufferPos += packNodeId(currentBufferPos, newNode->getNodeID());
-                        
-                        // send the constructed list back to this node
-                        nodeList->getNodeSocket()->send((sockaddr*)&replyDestinationSocket,
-                                                        broadcastPacket,
-                                                        (currentBufferPos - startPointer) + numHeaderBytes);
-                    }
-                }
-            } else if (packetData[0] == PACKET_TYPE_REQUEST_ASSIGNMENT) {
-                
-                qDebug("Received a request for assignment.\n");
-                
-                ::assignmentQueueMutex.lock();
-                
-                // this is an unassigned client talking to us directly for an assignment
-                // go through our queue and see if there are any assignments to give out
-                std::deque<Assignment*>::iterator assignment = ::assignmentQueue.begin();
-                
-                while (assignment != ::assignmentQueue.end()) {
-                    // construct the requested assignment from the packet data
-                    Assignment requestAssignment(packetData, receivedBytes);
-                    
-                    if (requestAssignment.getType() == Assignment::AllTypes ||
-                        (*assignment)->getType() == requestAssignment.getType()) {
-                        
-                        // give this assignment out, either the type matches or the requestor said they will take any
-                        int numHeaderBytes = populateTypeAndVersion(broadcastPacket, PACKET_TYPE_CREATE_ASSIGNMENT);
-                        int numAssignmentBytes = (*assignment)->packToBuffer(broadcastPacket + numHeaderBytes);
-                        
-                        nodeList->getNodeSocket()->send((sockaddr*) &nodePublicAddress,
-                                                        broadcastPacket,
-                                                        numHeaderBytes + numAssignmentBytes);
-                        
-                        if ((*assignment)->getType() == Assignment::AgentType) {
-                            // if this is a script assignment we need to delete it to avoid a memory leak
-                            // or if there is more than one instance to send out, simpy decrease the number of instances
-                            if ((*assignment)->getNumberOfInstances() > 1) {
-                                (*assignment)->decrementNumberOfInstances();
-                            } else {
-                                ::assignmentQueue.erase(assignment);
-                                delete *assignment;
-                            }
-                        } else {
-                            Assignment *sentAssignment = *assignment;
-                            // remove the assignment from the queue
-                            ::assignmentQueue.erase(assignment);
-                            
-                            if (sentAssignment->getType() != Assignment::VoxelServerType) {
-                                // keep audio-mixer and avatar-mixer assignments in the queue
-                                // until we get a check-in from that GUID
-                                // but stick it at the back so the others have a chance to go out
-                                
-                                ::assignmentQueue.push_back(sentAssignment);
-                            }
-                        }
-                        
-                        // stop looping, we've handed out an assignment
-                        break;
-                    } else {
-                        // push forward the iterator to check the next assignment
-                        assignment++;
-                    }
-                }
-                
-                ::assignmentQueueMutex.unlock();
-            } else if (packetData[0] == PACKET_TYPE_CREATE_ASSIGNMENT) {
-                // this is a create assignment likely recieved from a server needed more clients to help with load
-                
-                // unpack it
-                Assignment* createAssignment = new Assignment(packetData, receivedBytes);
-                
-                qDebug() << "Received a create assignment -" << *createAssignment << "\n";
-                
-                // add the assignment at the back of the queue
-                ::assignmentQueueMutex.lock();
-                ::assignmentQueue.push_back(createAssignment);
-                ::assignmentQueueMutex.unlock();
-            }
-        }
-        
-        if (Logging::shouldSendStats()) {
-            if (usecTimestampNow() - usecTimestamp(&lastStatSendTime) >= (NODE_COUNT_STAT_INTERVAL_MSECS * 1000)) {
-                // time to send our count of nodes and servers to logstash
-                const char NODE_COUNT_LOGSTASH_KEY[] = "ds-node-count";
-                
-                Logging::stashValue(STAT_TYPE_TIMER, NODE_COUNT_LOGSTASH_KEY, nodeList->getNumAliveNodes());
-                
-                gettimeofday(&lastStatSendTime, NULL);
-            }
-        }
-    }
-
-    return 0;
+    return domainServer.run();
 }
 

interface/CMakeLists.txt

@@ -52,6 +52,7 @@ find_package(Qt5Multimedia REQUIRED)
 find_package(Qt5Network REQUIRED)
 find_package(Qt5OpenGL REQUIRED)
 find_package(Qt5Svg REQUIRED)
+find_package(Qt5WebKit REQUIRED)
 find_package(Qt5WebKitWidgets REQUIRED)
 
 if (APPLE)
@@ -76,10 +77,6 @@ if (APPLE)
   endforeach()  
 endif (APPLE)
 
-set(QUAZIP_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/external/quazip)
-add_subdirectory(external/fervor/)
-include_directories(external/fervor/)
-
 # create the executable, make it a bundle on OS X
 add_executable(${TARGET_NAME} MACOSX_BUNDLE ${INTERFACE_SRCS})
 
@@ -112,7 +109,7 @@ if (OPENNI_FOUND AND NOT DISABLE_OPENNI)
     target_link_libraries(${TARGET_NAME} ${OPENNI_LIBRARIES})
 endif (OPENNI_FOUND AND NOT DISABLE_OPENNI)
 
-qt5_use_modules(${TARGET_NAME} Core Gui Multimedia Network OpenGL Svg)
+qt5_use_modules(${TARGET_NAME} Core Gui Multimedia Network OpenGL Svg WebKit WebKitWidgets)
 
 # include headers for interface and InterfaceConfig.
 include_directories(
@@ -141,7 +138,6 @@ target_link_libraries(
   ${MOTIONDRIVER_LIBRARIES}
   ${OPENCV_LIBRARIES} 
   ${ZLIB_LIBRARIES}
-  fervor
 )
 
 if (APPLE)

interface/external/fervor/CMakeLists.txt

@@ -1,35 +0,0 @@
-cmake_minimum_required(VERSION 2.8)
-project(Fervor)
-
-find_package(Qt5Core REQUIRED)
-find_package(Qt5Network REQUIRED)
-find_package(Qt5Widgets REQUIRED)
-find_package(Qt5WebKitWidgets REQUIRED)
-
-add_definitions(-DFV_GUI)
-
-file(GLOB FERVOR_SOURCES *.cpp)
-file(GLOB FERVOR_HEADERS *.h)
-
-file(GLOB FERVOR_UI *.ui)
-
-qt5_wrap_ui(FERVOR_WRAPPED_UI ${FERVOR_UI})
-
-LIST(GET FERVOR_HEADERS 1 FIRST_HEADER)
-GET_FILENAME_COMPONENT(HEADER_PATH ${FIRST_HEADER} PATH)
-list(REMOVE_ITEM FERVOR_HEADERS ${HEADER_PATH}/fvversioncomparator.h)
-
-file(GLOB FERVOR_UI *.ui)
-
-set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/../cmake/modules/")
-find_package(Quazip REQUIRED)
-
-include_directories(
-  ${CMAKE_CURRENT_BINARY_DIR}
-  ${QUAZIP_INCLUDE_DIRS}
-)
-
-add_library(fervor ${FERVOR_SOURCES} ${FERVOR_HEADERS} ${FERVOR_MOC_SOURCES} ${FERVOR_WRAPPED_UI})
-target_link_libraries(fervor ${QUAZIP_LIBRARIES})
-
-qt5_use_modules(fervor Core Network Widgets WebKitWidgets)

interface/external/fervor/fvavailableupdate.cpp

@@ -1,97 +0,0 @@
-#include "fvavailableupdate.h"
-
-FvAvailableUpdate::FvAvailableUpdate(QObject *parent) :
-	QObject(parent)
-{
-	// noop
-}
-
-QString FvAvailableUpdate::GetTitle()
-{
-	return m_title;
-}
-
-void FvAvailableUpdate::SetTitle(QString title)
-{
-	m_title = title;
-}
-
-QUrl FvAvailableUpdate::GetReleaseNotesLink()
-{
-	return m_releaseNotesLink;
-}
-
-void FvAvailableUpdate::SetReleaseNotesLink(QUrl releaseNotesLink)
-{
-	m_releaseNotesLink = releaseNotesLink;
-}
-
-void FvAvailableUpdate::SetReleaseNotesLink(QString releaseNotesLink)
-{
-	SetReleaseNotesLink(QUrl(releaseNotesLink));
-}
-
-QString FvAvailableUpdate::GetPubDate()
-{
-	return m_pubDate;
-}
-
-void FvAvailableUpdate::SetPubDate(QString pubDate)
-{
-	m_pubDate = pubDate;
-}
-
-QUrl FvAvailableUpdate::GetEnclosureUrl()
-{
-	return m_enclosureUrl;
-}
-
-void FvAvailableUpdate::SetEnclosureUrl(QUrl enclosureUrl)
-{
-	m_enclosureUrl = enclosureUrl;
-}
-
-void FvAvailableUpdate::SetEnclosureUrl(QString enclosureUrl)
-{
-	SetEnclosureUrl(QUrl(enclosureUrl));
-}
-
-QString FvAvailableUpdate::GetEnclosureVersion()
-{
-	return m_enclosureVersion;
-}
-
-void FvAvailableUpdate::SetEnclosureVersion(QString enclosureVersion)
-{
-	m_enclosureVersion = enclosureVersion;
-}
-
-QString FvAvailableUpdate::GetEnclosurePlatform()
-{
-	return m_enclosurePlatform;
-}
-
-void FvAvailableUpdate::SetEnclosurePlatform(QString enclosurePlatform)
-{
-	m_enclosurePlatform = enclosurePlatform;
-}
-
-unsigned long FvAvailableUpdate::GetEnclosureLength()
-{
-	return m_enclosureLength;
-}
-
-void FvAvailableUpdate::SetEnclosureLength(unsigned long enclosureLength)
-{
-	m_enclosureLength = enclosureLength;
-}
-
-QString FvAvailableUpdate::GetEnclosureType()
-{
-	return m_enclosureType;
-}
-
-void FvAvailableUpdate::SetEnclosureType(QString enclosureType)
-{
-	m_enclosureType = enclosureType;
-}

interface/external/fervor/fvavailableupdate.h

@@ -1,51 +0,0 @@
-#ifndef FVAVAILABLEUPDATE_H
-#define FVAVAILABLEUPDATE_H
-
-#include <QObject>
-#include <QUrl>
-
-class FvAvailableUpdate : public QObject
-{
-	Q_OBJECT
-public:
-	explicit FvAvailableUpdate(QObject *parent = 0);
-
-	QString GetTitle();
-	void SetTitle(QString title);
-
-	QUrl GetReleaseNotesLink();
-	void SetReleaseNotesLink(QUrl releaseNotesLink);
-	void SetReleaseNotesLink(QString releaseNotesLink);
-
-	QString GetPubDate();
-	void SetPubDate(QString pubDate);
-
-	QUrl GetEnclosureUrl();
-	void SetEnclosureUrl(QUrl enclosureUrl);
-	void SetEnclosureUrl(QString enclosureUrl);
-
-	QString GetEnclosureVersion();
-	void SetEnclosureVersion(QString enclosureVersion);
-
-	QString GetEnclosurePlatform();
-	void SetEnclosurePlatform(QString enclosurePlatform);
-
-	unsigned long GetEnclosureLength();
-	void SetEnclosureLength(unsigned long enclosureLength);
-
-	QString GetEnclosureType();
-	void SetEnclosureType(QString enclosureType);
-
-private:
-	QString m_title;
-	QUrl m_releaseNotesLink;
-	QString m_pubDate;
-	QUrl m_enclosureUrl;
-	QString m_enclosureVersion;
-	QString m_enclosurePlatform;
-	unsigned long m_enclosureLength;
-	QString m_enclosureType;
-
-};
-
-#endif // FVAVAILABLEUPDATE_H

interface/external/fervor/fvignoredversions.cpp

@@ -1,74 +0,0 @@
-#include "fvignoredversions.h"
-#include "fvversioncomparator.h"
-#include <QSettings>
-#include <QCoreApplication>
-#include <string>
-
-// QSettings key for the latest skipped version
-#define FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY	"FVLatestSkippedVersion"
-
-
-FVIgnoredVersions::FVIgnoredVersions(QObject *parent) :
-QObject(parent)
-{
-	// noop
-}
-
-bool FVIgnoredVersions::VersionIsIgnored(QString version)
-{
-	// We assume that variable 'version' contains either:
-	//	1) The current version of the application (ignore)
-	//	2) The version that was skipped before and thus stored in QSettings (ignore)
-	//	3) A newer version (don't ignore)
-	// 'version' is not likely to contain an older version in any case.
-    
-	if (version == QCoreApplication::applicationVersion()) {
-		return true;
-	}
-    
-    QSettings settings(QSettings::NativeFormat,
-					   QSettings::UserScope,
-					   QCoreApplication::organizationDomain(),
-					   QCoreApplication::applicationName());
-    
-	//QSettings settings;
-	if (settings.contains(FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY)) {
-		QString lastSkippedVersion = settings.value(FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY).toString();
-		if (version == lastSkippedVersion) {
-			// Implicitly skipped version - skip
-			return true;
-		}
-	}
-    
-	std::string currentAppVersion = QCoreApplication::applicationVersion().toStdString();
-	std::string suggestedVersion = std::string(version.toStdString());
-	if (FvVersionComparator::CompareVersions(currentAppVersion, suggestedVersion) == FvVersionComparator::kAscending) {
-		// Newer version - do not skip
-		return false;
-	}
-    
-	// Fallback - skip
-	return true;
-}
-
-void FVIgnoredVersions::IgnoreVersion(QString version)
-{
-	if (version == QCoreApplication::applicationVersion()) {
-		// Don't ignore the current version
-		return;
-	}
-    
-	if (version.isEmpty()) {
-		return;
-	}
-    
-    QSettings settings(QSettings::NativeFormat,
-					   QSettings::UserScope,
-					   QCoreApplication::organizationDomain(),
-					   QCoreApplication::applicationName());
-    
-
-	settings.setValue(FV_IGNORED_VERSIONS_LATEST_SKIPPED_VERSION_KEY, version);
-    
-	return;
-}

interface/external/fervor/fvignoredversions.h

@@ -1,19 +0,0 @@
-#ifndef FVIGNOREDVERSIONS_H
-#define FVIGNOREDVERSIONS_H
-
-#include <QObject>
-
-class FVIgnoredVersions : public QObject
-{
-	Q_OBJECT
-
-public:
-	static bool VersionIsIgnored(QString version);
-	static void IgnoreVersion(QString version);
-	
-private:
-	explicit FVIgnoredVersions(QObject *parent = 0);
-	
-};
-
-#endif // FVIGNOREDVERSIONS_H

interface/external/fervor/fvplatform.cpp

@@ -1,210 +0,0 @@
-#include "fvplatform.h"
-#include <QtGlobal>
-#include <QDebug>
-
-FvPlatform::FvPlatform(QObject *parent) :
-	QObject(parent)
-{
-	// noop
-}
-
-bool FvPlatform::CurrentlyRunningOnPlatform(QString platform)
-{
-	platform = platform.toUpper().trimmed();
-	if (platform.isEmpty()) {
-		return false;
-	}
-
-	// Defined on AIX.
-#ifdef Q_OS_AIX
-	if (platform == "Q_OS_AIX") {
-		return true;
-	}
-#endif
-
-	// Q_OS_BSD4 ("Defined on Any BSD 4.4 system") intentionally skipped.
-
-	// Defined on BSD/OS.
-#ifdef Q_OS_BSDI
-	if (platform == "Q_OS_BSDI") {
-		return true;
-	}
-#endif
-
-	// Defined on Cygwin.
-#ifdef Q_OS_CYGWIN
-	if (platform == "Q_OS_CYGWIN") {
-		return true;
-	}
-#endif
-
-	// Q_OS_DARWIN ("Defined on Darwin OS (synonym for Q_OS_MAC)") intentionally skipped.
-
-	// Defined on DG/UX.
-#ifdef Q_OS_DGUX
-	if (platform == "Q_OS_DGUX") {
-		return true;
-	}
-#endif
-
-	// Defined on DYNIX/ptx.
-#ifdef Q_OS_DYNIX
-	if (platform == "Q_OS_DYNIX") {
-		return true;
-	}
-#endif
-
-	// Defined on FreeBSD.
-#ifdef Q_OS_FREEBSD
-	if (platform == "Q_OS_FREEBSD") {
-		return true;
-	}
-#endif
-
-	// Defined on HP-UX.
-#ifdef Q_OS_HPUX
-	if (platform == "Q_OS_HPUX") {
-		return true;
-	}
-#endif
-
-	// Defined on GNU Hurd.
-#ifdef Q_OS_HURD
-	if (platform == "Q_OS_HURD") {
-		return true;
-	}
-#endif
-
-	// Defined on SGI Irix.
-#ifdef Q_OS_IRIX
-	if (platform == "Q_OS_IRIX") {
-		return true;
-	}
-#endif
-
-	// Defined on Linux.
-#ifdef Q_OS_LINUX
-	if (platform == "Q_OS_LINUX") {
-		return true;
-	}
-#endif
-
-	// Defined on LynxOS.
-#ifdef Q_OS_LYNX
-	if (platform == "Q_OS_LYNX") {
-		return true;
-	}
-#endif
-
-	// Defined on MAC OS (synonym for Darwin).
-#ifdef Q_OS_MAC
-	if (platform == "Q_OS_MAC") {
-		return true;
-	}
-#endif
-
-	// Q_OS_MSDOS ("Defined on MS-DOS and Windows") intentionally skipped.
-
-	// Defined on NetBSD.
-#ifdef Q_OS_NETBSD
-	if (platform == "Q_OS_NETBSD") {
-		return true;
-	}
-#endif
-
-	// Defined on OS/2.
-#ifdef Q_OS_OS2
-	if (platform == "Q_OS_OS2") {
-		return true;
-	}
-#endif
-
-	// Defined on OpenBSD.
-#ifdef Q_OS_OPENBSD
-	if (platform == "Q_OS_OPENBSD") {
-		return true;
-	}
-#endif
-
-	// Defined on XFree86 on OS/2 (not PM).
-#ifdef Q_OS_OS2EMX
-	if (platform == "Q_OS_OS2EMX") {
-		return true;
-	}
-#endif
-
-	// Defined on HP Tru64 UNIX.
-#ifdef Q_OS_OSF
-	if (platform == "Q_OS_OSF") {
-		return true;
-	}
-#endif
-
-	// Defined on QNX Neutrino.
-#ifdef Q_OS_QNX
-	if (platform == "Q_OS_QNX") {
-		return true;
-	}
-#endif
-
-	// Defined on Reliant UNIX.
-#ifdef Q_OS_RELIANT
-	if (platform == "Q_OS_RELIANT") {
-		return true;
-	}
-#endif
-
-	// Defined on SCO OpenServer 5.
-#ifdef Q_OS_SCO
-	if (platform == "Q_OS_SCO") {
-		return true;
-	}
-#endif
-
-	// Defined on Sun Solaris.
-#ifdef Q_OS_SOLARIS
-	if (platform == "Q_OS_SOLARIS") {
-		return true;
-	}
-#endif
-
-	// Defined on Symbian.
-#ifdef Q_OS_SYMBIAN
-	if (platform == "Q_OS_SYMBIAN") {
-		return true;
-	}
-#endif
-
-	// Defined on DEC Ultrix.
-#ifdef Q_OS_ULTRIX
-	if (platform == "Q_OS_ULTRIX") {
-		return true;
-	}
-#endif
-
-	// Q_OS_UNIX ("Defined on Any UNIX BSD/SYSV system") intentionally skipped.
-
-	// Defined on UnixWare 7, Open UNIX 8.
-#ifdef Q_OS_UNIXWARE
-	if (platform == "Q_OS_UNIXWARE") {
-		return true;
-	}
-#endif
-
-	// Defined on Windows CE (note: goes before Q_OS_WIN32)
-#ifdef Q_OS_WINCE
-	if (platform == "Q_OS_WINCE") {
-		return true;
-	}
-#endif
-
-	// Defined on all supported versions of Windows.
-#ifdef Q_OS_WIN32
-	if (platform == "Q_OS_WIN32") {
-		return true;
-	}
-#endif
-
-	// Fallback
-	return false;
-}

interface/external/fervor/fvplatform.h

@@ -1,18 +0,0 @@
-#ifndef FVPLATFORM_H
-#define FVPLATFORM_H
-
-#include <QtCore/QObject>
-
-class FvPlatform : public QObject
-{
-	Q_OBJECT
-
-public:
-	static bool CurrentlyRunningOnPlatform(QString platform);
-
-private:
-	explicit FvPlatform(QObject *parent = 0);
-		
-};
-
-#endif // FVPLATFORM_H

interface/external/fervor/fvupdatedownloadprogress.cpp

@@ -1,26 +0,0 @@
-#include "fvupdatedownloadprogress.h"
-
-FvUpdateDownloadProgress::FvUpdateDownloadProgress(QWidget *parent)
-	: QWidget(parent, Qt::SplashScreen)
-{
-	ui.setupUi(this);
-
-	ui.progress->setValue(0);
-
-}
-
-FvUpdateDownloadProgress::~FvUpdateDownloadProgress()
-{
-
-}
-
-void FvUpdateDownloadProgress::downloadProgress ( qint64 bytesReceived, qint64 bytesTotal )
-{
-	ui.progress->setValue( ((float)bytesReceived / (float)bytesTotal) * 100 );
-}
-
-void FvUpdateDownloadProgress::close()
-{
-	this->deleteLater();
-	QWidget::close();
-}

interface/external/fervor/fvupdatedownloadprogress.h

@@ -1,23 +0,0 @@
-#ifndef FVUPDATEDOWNLOADPROGRESS_H
-#define FVUPDATEDOWNLOADPROGRESS_H
-
-#include <QWidget>
-#include "ui_fvupdatedownloadprogress.h"
-
-class FvUpdateDownloadProgress : public QWidget
-{
-	Q_OBJECT
-
-public:
-	FvUpdateDownloadProgress(QWidget *parent = 0);
-	~FvUpdateDownloadProgress();
-
-public slots:
-	void downloadProgress ( qint64 bytesReceived, qint64 bytesTotal );
-	void close();
-
-private:
-	Ui::FvUpdateDownloadProgress ui;
-};
-
-#endif // FVUPDATEDOWNLOADPROGRESS_H

interface/external/fervor/fvupdatedownloadprogress.ui

@@ -1,94 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>FvUpdateDownloadProgress</class>
- <widget class="QWidget" name="FvUpdateDownloadProgress">
-  <property name="windowModality">
-   <enum>Qt::ApplicationModal</enum>
-  </property>
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>558</width>
-    <height>70</height>
-   </rect>
-  </property>
-  <property name="sizePolicy">
-   <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
-    <horstretch>0</horstretch>
-    <verstretch>0</verstretch>
-   </sizepolicy>
-  </property>
-  <property name="windowTitle">
-   <string>FvUpdateDownloadProgress</string>
-  </property>
-  <layout class="QGridLayout" name="gridLayout">
-   <property name="margin">
-    <number>0</number>
-   </property>
-   <property name="spacing">
-    <number>0</number>
-   </property>
-   <item row="0" column="0">
-    <widget class="QFrame" name="frame">
-     <property name="frameShape">
-      <enum>QFrame::WinPanel</enum>
-     </property>
-     <property name="frameShadow">
-      <enum>QFrame::Raised</enum>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout">
-      <property name="spacing">
-       <number>8</number>
-      </property>
-      <item>
-       <widget class="QLabel" name="label">
-        <property name="font">
-         <font>
-          <pointsize>12</pointsize>
-         </font>
-        </property>
-        <property name="layoutDirection">
-         <enum>Qt::LeftToRight</enum>
-        </property>
-        <property name="frameShape">
-         <enum>QFrame::NoFrame</enum>
-        </property>
-        <property name="frameShadow">
-         <enum>QFrame::Plain</enum>
-        </property>
-        <property name="text">
-         <string>Downloading Update...</string>
-        </property>
-        <property name="alignment">
-         <set>Qt::AlignCenter</set>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QProgressBar" name="progress">
-        <property name="font">
-         <font>
-          <pointsize>8</pointsize>
-         </font>
-        </property>
-        <property name="value">
-         <number>24</number>
-        </property>
-        <property name="textVisible">
-         <bool>false</bool>
-        </property>
-        <property name="invertedAppearance">
-         <bool>false</bool>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-  </layout>
- </widget>
- <layoutdefault spacing="6" margin="11"/>
- <resources/>
- <connections/>
-</ui>

interface/external/fervor/fvupdater.cpp

@@ -1,908 +0,0 @@
-#include "fvupdater.h"
-#include "fvplatform.h"
-#include "fvignoredversions.h"
-#include "fvavailableupdate.h"
-#include <QCoreApplication>
-#include <QtNetwork>
-#include <QDebug>
-#include <QSettings>
-#include "quazip.h"
-#include "quazipfile.h"
-
-#ifdef Q_OS_MAC
-#include "CoreFoundation/CoreFoundation.h"
-#endif
-
-#ifdef FV_GUI
-#include "fvupdatewindow.h"
-#include "fvupdatedownloadprogress.h"
-#include <QMessageBox>
-#include <QDesktopServices>
-#else
-// QSettings key for automatic update installation
-#define FV_NEW_VERSION_POLICY_KEY              "FVNewVersionPolicy"
-#endif
-
-#ifdef FV_DEBUG
-	// Unit tests
-#	include "fvversioncomparatortest.h"
-#endif
-
-extern QSettings* settings;
-
-FvUpdater* FvUpdater::m_Instance = 0;
-
-
-FvUpdater* FvUpdater::sharedUpdater()
-{
-	static QMutex mutex;
-	if (! m_Instance) {
-		mutex.lock();
-
-		if (! m_Instance) {
-			m_Instance = new FvUpdater;
-		}
-
-		mutex.unlock();
-	}
-
-	return m_Instance;
-}
-
-void FvUpdater::drop()
-{
-	static QMutex mutex;
-	mutex.lock();
-	delete m_Instance;
-	m_Instance = 0;
-	mutex.unlock();
-}
-
-FvUpdater::FvUpdater() : QObject(0)
-{
-	m_reply = 0;
-#ifdef FV_GUI
-	m_updaterWindow = 0;
-#endif
-	m_proposedUpdate = 0;
-	m_requiredSslFingerprint = "";
-	htAuthUsername = "";
-	htAuthPassword = "";
-	skipVersionAllowed = true;
-	remindLaterAllowed = true;
-
-	connect(&m_qnam, SIGNAL(authenticationRequired(QNetworkReply*, QAuthenticator*)),this, SLOT(authenticationRequired(QNetworkReply*, QAuthenticator*)));
-
-	// Translation mechanism
-	installTranslator();
-
-#ifdef FV_DEBUG
-	// Unit tests
-	FvVersionComparatorTest* test = new FvVersionComparatorTest();
-	test->runAll();
-	delete test;
-#endif
-
-}
-
-FvUpdater::~FvUpdater()
-{
-	if (m_proposedUpdate) {
-		delete m_proposedUpdate;
-		m_proposedUpdate = 0;
-	}
-
-#ifdef FV_GUI
-	hideUpdaterWindow();
-#endif
-}
-
-void FvUpdater::installTranslator()
-{
-	QTranslator translator;
-	QString locale = QLocale::system().name();
-	translator.load(QString("fervor_") + locale);
-
-#if QT_VERSION < 0x050000
-    QTextCodec::setCodecForTr(QTextCodec::codecForName("utf8"));
-#endif
-
-	qApp->installTranslator(&translator);
-}
-
-#ifdef FV_GUI
-void FvUpdater::showUpdaterWindowUpdatedWithCurrentUpdateProposal()
-{
-	// Destroy window if already exists
-	hideUpdaterWindow();
-
-	// Create a new window
-	m_updaterWindow = new FvUpdateWindow(NULL, skipVersionAllowed, remindLaterAllowed);
-	m_updaterWindow->UpdateWindowWithCurrentProposedUpdate();
-	m_updaterWindow->show();
-}
-
-void FvUpdater::hideUpdaterWindow()
-{
-	if (m_updaterWindow) {
-		if (! m_updaterWindow->close()) {
-			qWarning() << "Update window didn't close, leaking memory from now on";
-		}
-
-		// not deleting because of Qt::WA_DeleteOnClose
-
-		m_updaterWindow = 0;
-	}
-}
-
-void FvUpdater::updaterWindowWasClosed()
-{
-	// (Re-)nullify a pointer to a destroyed QWidget or you're going to have a bad time.
-	m_updaterWindow = 0;
-}
-#endif
-
-void FvUpdater::SetFeedURL(QUrl feedURL)
-{
-	m_feedURL = feedURL;
-}
-
-void FvUpdater::SetFeedURL(QString feedURL)
-{
-	SetFeedURL(QUrl(feedURL));
-}
-
-QString FvUpdater::GetFeedURL()
-{
-	return m_feedURL.toString();
-}
-
-FvAvailableUpdate* FvUpdater::GetProposedUpdate()
-{
-	return m_proposedUpdate;
-}
-
-
-void FvUpdater::InstallUpdate()
-{
-	if(m_proposedUpdate==NULL)
-	{
-		qWarning() << "Abort Update: No update prososed! This should not happen.";
-		return;
-	}
-
-	// Prepare download
-	QUrl url = m_proposedUpdate->GetEnclosureUrl();
-
-	// Check SSL Fingerprint if required
-	if(url.scheme()=="https" && !m_requiredSslFingerprint.isEmpty())
-		if( !checkSslFingerPrint(url) )	// check failed
-		{	
-			qWarning() << "Update aborted.";
-			return;
-		}
-
-	// Start Download
-	QNetworkReply* reply = m_qnam.get(QNetworkRequest(url));
-	connect(reply, SIGNAL(finished()), this, SLOT(httpUpdateDownloadFinished()));
-
-	// Maybe Check request 's return value
-	if (reply->error() != QNetworkReply::NoError)
-	{
-		qDebug()<<"Unable to download the update: "<<reply->errorString();
-		return;
-	}
-	else
-		qDebug()<<"OK";
-
-	// Show download Window
-#ifdef FV_GUI
-	FvUpdateDownloadProgress* dlwindow = new FvUpdateDownloadProgress(NULL);
-	connect(reply, SIGNAL(downloadProgress(qint64, qint64)), dlwindow, SLOT(downloadProgress(qint64, qint64) ));
-	connect(&m_qnam, SIGNAL(finished(QNetworkReply*)), dlwindow, SLOT(close()));
-	dlwindow->show();
-#endif
-
-	emit (updatedFinishedSuccessfully());
-
-#ifdef FV_GUI
-	hideUpdaterWindow();
-#endif
-}
-
-void FvUpdater::httpUpdateDownloadFinished()
-{
-	QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
-	if(reply==NULL)
-	{
-		qWarning()<<"The slot httpUpdateDownloadFinished() should only be invoked by S&S.";
-		return;
-	}
-
-	if(reply->error() == QNetworkReply::NoError)
-	{
-		int httpstatuscode = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toUInt();
-
-		// no error received?
-		if (reply->error() == QNetworkReply::NoError)
-		{
-			if (reply->isReadable())
-			{
-#ifdef Q_OS_MAC
-                CFURLRef appURLRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
-                char path[PATH_MAX];
-                if (!CFURLGetFileSystemRepresentation(appURLRef, TRUE, (UInt8 *)path, PATH_MAX)) {
-                    // error!
-                }
-
-                CFRelease(appURLRef);
-                QString filePath = QString(path);
-                QString rootDirectory = filePath.left(filePath.lastIndexOf("/"));
-#else
-                QString rootDirectory = QCoreApplication::applicationDirPath() + "/";
-#endif
-                
-				// Write download into File
-				QFileInfo fileInfo=reply->url().path();
-				QString fileName = rootDirectory + fileInfo.fileName();
-				//qDebug()<<"Writing downloaded file into "<<fileName;
-	
-				QFile file(fileName);
-				file.open(QIODevice::WriteOnly);
-				file.write(reply->readAll());
-				file.close();
-
-				// Retrieve List of updated files (Placed in an extra scope to avoid QuaZIP handles the archive permanently and thus avoids the deletion.)
-				{	
-					QuaZip zip(fileName);
-					if (!zip.open(QuaZip::mdUnzip)) {
-						qWarning("testRead(): zip.open(): %d", zip.getZipError());
-						return;
-					}
-					zip.setFileNameCodec("IBM866");
-					QList<QuaZipFileInfo> updateFiles = zip.getFileInfoList();
-		
-					// Rename all current files with available update.
-					for (int i=0;i<updateFiles.size();i++)
-					{
-						QString sourceFilePath = rootDirectory + "\\" + updateFiles[i].name;
-						QDir appDir( QCoreApplication::applicationDirPath() );
-
-						QFileInfo file(	sourceFilePath );
-						if(file.exists())
-						{
-							//qDebug()<<tr("Moving file %1 to %2").arg(sourceFilePath).arg(sourceFilePath+".oldversion");
-							appDir.rename( sourceFilePath, sourceFilePath+".oldversion" );
-						}
-					}
-				}
-
-				// Install updated Files
-				unzipUpdate(fileName, rootDirectory);
-
-				// Delete update archive
-                while(QFile::remove(fileName) )
-                {
-                };
-
-				// Restart ap to clean up and start usual business
-				restartApplication();
-
-			}
-			else qDebug()<<"Error: QNetworkReply is not readable!";
-		}
-		else 
-		{
-			qDebug()<<"Download errors ocurred! HTTP Error Code:"<<httpstatuscode;
-		}
-
-		reply->deleteLater();
-    }	// If !reply->error END
-}	// httpUpdateDownloadFinished END
-
-bool FvUpdater::unzipUpdate(const QString & filePath, const QString & extDirPath, const QString & singleFileName )
-{
-	QuaZip zip(filePath);
-
-    if (!zip.open(QuaZip::mdUnzip)) {
-		qWarning()<<tr("Error: Unable to open zip archive %1 for unzipping: %2").arg(filePath).arg(zip.getZipError());
-		return false;
-	}
-
-	zip.setFileNameCodec("IBM866");
-
-	//qWarning("Update contains %d files\n", zip.getEntriesCount());
-
-	QuaZipFileInfo info;
-	QuaZipFile file(&zip);
-	QFile out;
-	QString name;
-	QDir appDir(extDirPath);
-	for (bool more = zip.goToFirstFile(); more; more = zip.goToNextFile())
-	{
-		if (!zip.getCurrentFileInfo(&info)) {
-			qWarning()<<tr("Error: Unable to retrieve fileInfo about the file to extract: %2").arg(zip.getZipError());
-			return false;
-		}
-
-		if (!singleFileName.isEmpty())
-			if (!info.name.contains(singleFileName))
-				continue;
-
-		if (!file.open(QIODevice::ReadOnly)) {
-			qWarning()<<tr("Error: Unable to open file %1 for unzipping: %2").arg(filePath).arg(file.getZipError());
-			return false;
-		}
-
-		name = QString("%1/%2").arg(extDirPath).arg(file.getActualFileName());
-
-		if (file.getZipError() != UNZ_OK) {
-			qWarning()<<tr("Error: Unable to retrieve zipped filename to unzip from %1: %2").arg(filePath).arg(file.getZipError());
-			return false;
-		}
-		
-		QFileInfo fi(name);
-		appDir.mkpath(fi.absolutePath() );	// Ensure that subdirectories - if required - exist 
-		out.setFileName(name);
-		out.open(QIODevice::WriteOnly);
-		out.write( file.readAll() );
-		out.close();
-
-		if (file.getZipError() != UNZ_OK) {
-			qWarning()<<tr("Error: Unable to unzip file %1: %2").arg(name).arg(file.getZipError());
-			return false;
-		}
-
-		if (!file.atEnd()) {
-			qWarning()<<tr("Error: Have read all available bytes, but pointer still does not show EOF: %1").arg(file.getZipError());
-			return false;
-		}
-
-		file.close();
-
-		if (file.getZipError() != UNZ_OK) {
-			qWarning()<<tr("Error: Unable to close zipped file %1: %2").arg(name).arg(file.getZipError());
-			return false;
-		}
-	}
-
-	zip.close();
-
-	if (zip.getZipError() != UNZ_OK) {
-		qWarning()<<tr("Error: Unable to close zip archive file %1: %2").arg(filePath).arg(file.getZipError());
-		return false;
-	}
-
-	return true;
-}
-
-
-void FvUpdater::SkipUpdate()
-{
-	qDebug() << "Skip update";
-
-	FvAvailableUpdate* proposedUpdate = GetProposedUpdate();
-	if (! proposedUpdate) {
-		qWarning() << "Proposed update is NULL (shouldn't be at this point)";
-		return;
-	}
-
-	// Start ignoring this particular version
-	FVIgnoredVersions::IgnoreVersion(proposedUpdate->GetEnclosureVersion());
-
-#ifdef FV_GUI
-	hideUpdaterWindow();
-#endif
-}
-
-void FvUpdater::RemindMeLater()
-{
-	//qDebug() << "Remind me later";
-
-#ifdef FV_GUI
-	hideUpdaterWindow();
-#endif
-}
-
-bool FvUpdater::CheckForUpdates(bool silentAsMuchAsItCouldGet)
-{
-	if (m_feedURL.isEmpty()) {
-		qCritical() << "Please set feed URL via setFeedURL() before calling CheckForUpdates().";
-		return false;
-	}
-
-	m_silentAsMuchAsItCouldGet = silentAsMuchAsItCouldGet;
-
-	// Check if application's organization name and domain are set, fail otherwise
-	// (nowhere to store QSettings to)
-	if (QCoreApplication::organizationName().isEmpty()) {
-		qCritical() << "QCoreApplication::organizationName is not set. Please do that.";
-		return false;
-	}
-	if (QCoreApplication::organizationDomain().isEmpty()) {
-		qCritical() << "QCoreApplication::organizationDomain is not set. Please do that.";
-		return false;
-	}
-
-	if(QCoreApplication::applicationName().isEmpty()) {
-		qCritical() << "QCoreApplication::applicationName is not set. Please do that.";
-		return false;
-	}
-
-	// Set application version is not set yet
-	if (QCoreApplication::applicationVersion().isEmpty()) {
-		qCritical() << "QCoreApplication::applicationVersion is not set. Please do that.";
-		return false;
-	}
-
-	cancelDownloadFeed();
-	m_httpRequestAborted = false;
-	startDownloadFeed(m_feedURL);
-
-	return true;
-}
-
-bool FvUpdater::CheckForUpdatesSilent()
-{
-	return CheckForUpdates(true);
-}
-
-bool FvUpdater::CheckForUpdatesNotSilent()
-{
-	return CheckForUpdates(false);
-}
-
-
-void FvUpdater::startDownloadFeed(QUrl url)
-{
-	m_xml.clear();
-
-	// Check SSL Fingerprint if required
-	if(url.scheme()=="https" && !m_requiredSslFingerprint.isEmpty())
-		if( !checkSslFingerPrint(url) )	// check failed
-		{	
-			qWarning() << "Update aborted.";
-			return;
-		}
-
-
-	m_reply = m_qnam.get(QNetworkRequest(url));
-
-	connect(m_reply, SIGNAL(readyRead()), this, SLOT(httpFeedReadyRead()));
-	connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)), this, SLOT(httpFeedUpdateDataReadProgress(qint64, qint64)));
-	connect(m_reply, SIGNAL(finished()), this, SLOT(httpFeedDownloadFinished()));
-}
-
-void FvUpdater::cancelDownloadFeed()
-{
-	if (m_reply) {
-		m_httpRequestAborted = true;
-		m_reply->abort();
-	}
-}
-
-void FvUpdater::httpFeedReadyRead()
-{
-	// this slot gets called every time the QNetworkReply has new data.
-	// We read all of its new data and write it into the file.
-	// That way we use less RAM than when reading it at the finished()
-	// signal of the QNetworkReply
-	m_xml.addData(m_reply->readAll());
-}
-
-void FvUpdater::httpFeedUpdateDataReadProgress(qint64 bytesRead,
-											   qint64 totalBytes)
-{
-	Q_UNUSED(bytesRead);
-	Q_UNUSED(totalBytes);
-
-	if (m_httpRequestAborted) {
-		return;
-	}
-}
-
-void FvUpdater::httpFeedDownloadFinished()
-{
-	if (m_httpRequestAborted) {
-		m_reply->deleteLater();
-		return;
-	}
-
-	QVariant redirectionTarget = m_reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
-	if (m_reply->error()) {
-
-		// Error.
-		showErrorDialog(tr("Feed download failed: %1.").arg(m_reply->errorString()), false);
-
-	} else if (! redirectionTarget.isNull()) {
-		QUrl newUrl = m_feedURL.resolved(redirectionTarget.toUrl());
-
-		m_feedURL = newUrl;
-		m_reply->deleteLater();
-
-		startDownloadFeed(m_feedURL);
-		return;
-
-	} else {
-
-		// Done.
-		xmlParseFeed();
-
-	}
-
-	m_reply->deleteLater();
-	m_reply = 0;
-}
-
-bool FvUpdater::xmlParseFeed()
-{
-	QString currentTag, currentQualifiedTag;
-
-	QString xmlTitle, xmlLink, xmlReleaseNotesLink, xmlPubDate, xmlEnclosureUrl,
-			xmlEnclosureVersion, xmlEnclosurePlatform, xmlEnclosureType;
-	unsigned long xmlEnclosureLength;
-
-	// Parse
-	while (! m_xml.atEnd()) {
-
-		m_xml.readNext();
-
-		if (m_xml.isStartElement()) {
-
-			currentTag = m_xml.name().toString();
-			currentQualifiedTag = m_xml.qualifiedName().toString();
-
-			if (m_xml.name() == "item") {
-
-				xmlTitle.clear();
-				xmlLink.clear();
-				xmlReleaseNotesLink.clear();
-				xmlPubDate.clear();
-				xmlEnclosureUrl.clear();
-				xmlEnclosureVersion.clear();
-				xmlEnclosurePlatform.clear();
-				xmlEnclosureLength = 0;
-				xmlEnclosureType.clear();
-
-			} else if (m_xml.name() == "enclosure") {
-
-				QXmlStreamAttributes attribs = m_xml.attributes();
-
-				if (attribs.hasAttribute("fervor:platform"))
-				{
-					xmlEnclosurePlatform = attribs.value("fervor:platform").toString().trimmed();
-
-					if (FvPlatform::CurrentlyRunningOnPlatform(xmlEnclosurePlatform))
-					{
-						xmlEnclosureUrl = attribs.hasAttribute("url") ? attribs.value("url").toString().trimmed() : "";
-				
-						xmlEnclosureVersion = "";
-						if (attribs.hasAttribute("fervor:version")) 
-							xmlEnclosureVersion = attribs.value("fervor:version").toString().trimmed();
-						if (attribs.hasAttribute("sparkle:version"))
-							xmlEnclosureVersion = attribs.value("sparkle:version").toString().trimmed();
-				
-						xmlEnclosureLength = attribs.hasAttribute("length") ? attribs.value("length").toString().toLong() : 0;
-		
-						xmlEnclosureType = attribs.hasAttribute("type") ? attribs.value("type").toString().trimmed() : "";
-					}
-
-				}	// if hasAttribute flevor:platform END
-
-			}	// IF encosure END
-
-		} else if (m_xml.isEndElement()) {
-
-			if (m_xml.name() == "item") {
-
-				// That's it - we have analyzed a single <item> and we'll stop
-				// here (because the topmost is the most recent one, and thus
-				// the newest version.
-
-				return searchDownloadedFeedForUpdates(xmlTitle,
-													  xmlLink,
-													  xmlReleaseNotesLink,
-													  xmlPubDate,
-													  xmlEnclosureUrl,
-													  xmlEnclosureVersion,
-													  xmlEnclosurePlatform,
-													  xmlEnclosureLength,
-													  xmlEnclosureType);
-
-			}
-
-		} else if (m_xml.isCharacters() && ! m_xml.isWhitespace()) {
-
-			if (currentTag == "title") {
-				xmlTitle += m_xml.text().toString().trimmed();
-
-			} else if (currentTag == "link") {
-				xmlLink += m_xml.text().toString().trimmed();
-
-			} else if (currentQualifiedTag == "sparkle:releaseNotesLink") {
-				xmlReleaseNotesLink += m_xml.text().toString().trimmed();
-
-			} else if (currentTag == "pubDate") {
-				xmlPubDate += m_xml.text().toString().trimmed();
-
-			}
-
-		}
-
-		if (m_xml.error() && m_xml.error() != QXmlStreamReader::PrematureEndOfDocumentError) {
-
-			showErrorDialog(tr("Feed parsing failed: %1 %2.").arg(QString::number(m_xml.lineNumber()), m_xml.errorString()), false);
-			return false;
-
-		}
-	}
-
-	return false;
-}
-
-
-bool FvUpdater::searchDownloadedFeedForUpdates(QString xmlTitle,
-											   QString xmlLink,
-											   QString xmlReleaseNotesLink,
-											   QString xmlPubDate,
-											   QString xmlEnclosureUrl,
-											   QString xmlEnclosureVersion,
-											   QString xmlEnclosurePlatform,
-											   unsigned long xmlEnclosureLength,
-											   QString xmlEnclosureType)
-{
-	Q_UNUSED(xmlTitle);
-	Q_UNUSED(xmlPubDate);
-	Q_UNUSED(xmlEnclosureLength);
-	Q_UNUSED(xmlEnclosureType);
-
-	// Validate
-	if (xmlReleaseNotesLink.isEmpty()) {
-		if (xmlLink.isEmpty()) {
-			showErrorDialog(tr("Feed error: \"release notes\" link is empty"), false);
-			return false;
-		} else {
-			xmlReleaseNotesLink = xmlLink;
-		}
-	} else {
-		xmlLink = xmlReleaseNotesLink;
-	}
-	if (! (xmlLink.startsWith("http://") || xmlLink.startsWith("https://"))) {
-		showErrorDialog(tr("Feed error: invalid \"release notes\" link"), false);
-		return false;
-	}
-	if (xmlEnclosureUrl.isEmpty() || xmlEnclosureVersion.isEmpty() || xmlEnclosurePlatform.isEmpty()) {
-		showErrorDialog(tr("Feed error: invalid \"enclosure\" with the download link"), false);
-		return false;
-	}
-
-	// Relevant version?
-	if (FVIgnoredVersions::VersionIsIgnored(xmlEnclosureVersion)) {
-		qDebug() << "Version '" << xmlEnclosureVersion << "' is ignored, too old or something like that.";
-
-		showInformationDialog(tr("No updates were found."), false);
-
-		return true;	// Things have succeeded when you think of it.
-	}
-
-
-	//
-	// Success! At this point, we have found an update that can be proposed
-	// to the user.
-	//
-
-	if (m_proposedUpdate) {
-		delete m_proposedUpdate; m_proposedUpdate = 0;
-	}
-	m_proposedUpdate = new FvAvailableUpdate();
-	m_proposedUpdate->SetTitle(xmlTitle);
-	m_proposedUpdate->SetReleaseNotesLink(xmlReleaseNotesLink);
-	m_proposedUpdate->SetPubDate(xmlPubDate);
-	m_proposedUpdate->SetEnclosureUrl(xmlEnclosureUrl);
-	m_proposedUpdate->SetEnclosureVersion(xmlEnclosureVersion);
-	m_proposedUpdate->SetEnclosurePlatform(xmlEnclosurePlatform);
-	m_proposedUpdate->SetEnclosureLength(xmlEnclosureLength);
-	m_proposedUpdate->SetEnclosureType(xmlEnclosureType);
-
-#ifdef FV_GUI
-	// Show "look, there's an update" window
-	showUpdaterWindowUpdatedWithCurrentUpdateProposal();
-#else
-	// Decide ourselves what to do
-	decideWhatToDoWithCurrentUpdateProposal();
-#endif
-
-	return true;
-}
-
-
-void FvUpdater::showErrorDialog(QString message, bool showEvenInSilentMode)
-{
-	if (m_silentAsMuchAsItCouldGet) {
-		if (! showEvenInSilentMode) {
-			// Don't show errors in the silent mode
-			return;
-		}
-	}
-
-#ifdef FV_GUI
-	QMessageBox dlFailedMsgBox;
-	dlFailedMsgBox.setIcon(QMessageBox::Critical);
-	dlFailedMsgBox.setText(tr("Error"));
-	dlFailedMsgBox.setInformativeText(message);
-	dlFailedMsgBox.exec();
-#else
-	qCritical() << message;
-#endif
-}
-
-void FvUpdater::showInformationDialog(QString message, bool showEvenInSilentMode)
-{
-	if (m_silentAsMuchAsItCouldGet) {
-		if (! showEvenInSilentMode) {
-			// Don't show information dialogs in the silent mode
-			return;
-		}
-	}
-
-#ifdef FV_GUI
-	QMessageBox dlInformationMsgBox;
-	dlInformationMsgBox.setIcon(QMessageBox::Information);
-	dlInformationMsgBox.setText(tr("Information"));
-	dlInformationMsgBox.setInformativeText(message);
-	dlInformationMsgBox.exec();
-#else
-	qDebug() << message;
-#endif
-}
-
-void FvUpdater::finishUpdate(QString pathToFinish)
-{
-	pathToFinish = pathToFinish.isEmpty() ? QCoreApplication::applicationDirPath() : pathToFinish;
-	QDir appDir(pathToFinish);
-	appDir.setFilter( QDir::Files | QDir::Dirs );
-
-	QFileInfoList dirEntries = appDir.entryInfoList();
-	foreach (QFileInfo fi, dirEntries)
-	{
-		if ( fi.isDir() )
-		{
-            QString dirname = fi.fileName();
-            if ((dirname==".") || (dirname == ".."))
-                continue;
-			
-			// recursive clean up subdirectory
-			finishUpdate(fi.filePath());
-		}
-		else
-		{
-			if(fi.suffix()=="oldversion")
-				if( !appDir.remove( fi.absoluteFilePath() ) )
-					qDebug()<<"Error: Unable to clean up file: "<<fi.absoluteFilePath();
-
-		}
-	}	// For each dir entry END
-}
-
-void FvUpdater::restartApplication()
-{
-	// Spawn a new instance of myApplication:
-    QString app = QApplication::applicationFilePath();
-    QStringList arguments = QApplication::arguments();
-    QString wd = QDir::currentPath();
-    qDebug() << app << arguments << wd;
-    QProcess::startDetached(app, arguments, wd);
-    QApplication::exit();
-}
-
-void FvUpdater::setRequiredSslFingerPrint(QString md5)
-{
-	m_requiredSslFingerprint = md5.remove(":");
-}
-
-QString FvUpdater::getRequiredSslFingerPrint()
-{
-	return m_requiredSslFingerprint;
-}
-
-bool FvUpdater::checkSslFingerPrint(QUrl urltoCheck)
-{
-	if(urltoCheck.scheme()!="https")
-	{
-		qWarning()<<tr("SSL fingerprint check: The url %1 is not a ssl connection!").arg(urltoCheck.toString());
-		return false;
-	}
-
-	QSslSocket *socket = new QSslSocket(this);
-	socket->connectToHostEncrypted(urltoCheck.host(), 443);
-	if( !socket->waitForEncrypted(1000))	// waits until ssl emits encrypted(), max 1000msecs
-	{
-		qWarning()<<"SSL fingerprint check: Unable to connect SSL server: "<<socket->sslErrors();
-		return false;
-	}
-
-	QSslCertificate cert = socket->peerCertificate();
-
-	if(cert.isNull())
-	{
-		qWarning()<<"SSL fingerprint check: Unable to retrieve SSL server certificate.";
-		return false;
-	}
-
-	// COmpare digests
-	if(cert.digest().toHex() != m_requiredSslFingerprint)
-	{
-		qWarning()<<"SSL fingerprint check: FINGERPRINT MISMATCH! Server digest="<<cert.digest().toHex()<<", requiered ssl digest="<<m_requiredSslFingerprint;
-		return false;
-	}
-	
-	return true;
-}
-
-void FvUpdater::authenticationRequired ( QNetworkReply * reply, QAuthenticator * authenticator )
-{
-	if(reply==NULL || authenticator==NULL)
-		return;
-
-	if(!authenticator->user().isEmpty())	// If there is already a login user set but an authentication is still required: credentials must be wrong -> abort
-	{
-		reply->abort();
-		qWarning()<<"Http authentication: Wrong credentials!";
-		return;
-	}
-
-	authenticator->setUser(htAuthUsername);
-	authenticator->setPassword(htAuthPassword);
-}
-
-void FvUpdater::setHtAuthCredentials(QString user, QString pass)
-{
-	htAuthUsername = user;
-	htAuthPassword = pass;
-}
-
-void FvUpdater::setHtAuthUsername(QString user)
-{
-	htAuthUsername = user;
-}
-
-void FvUpdater::setHtAuthPassword(QString pass)
-{
-	htAuthPassword = pass;
-}
-
-void FvUpdater::setSkipVersionAllowed(bool allowed)
-{
-	skipVersionAllowed = allowed;
-}
-
-void FvUpdater::setRemindLaterAllowed(bool allowed)
-{
-	remindLaterAllowed = allowed;
-}
-
-bool FvUpdater::getSkipVersionAllowed()
-{
-	return skipVersionAllowed;
-}
-
-bool FvUpdater::getRemindLaterAllowed()
-{
-	return remindLaterAllowed;
-}
-
-#ifndef FV_GUI
-
-void FvUpdater::decideWhatToDoWithCurrentUpdateProposal()
-{
-	QString policy = settings->value(FV_NEW_VERSION_POLICY_KEY).toString();
-	if(policy == "install")
-		InstallUpdate();
-	else if(policy == "skip")
-		SkipUpdate();
-	else
-		RemindMeLater();
-}
-
-#endif
-

interface/external/fervor/fvupdater.h

@@ -1,183 +0,0 @@
-#ifndef FVUPDATER_H
-#define FVUPDATER_H
-
-#include <QObject>
-#include <QMutex>
-#include <QNetworkAccessManager>
-#include <QUrl>
-#include <QXmlStreamReader>
-class QNetworkReply;
-class FvUpdateWindow;
-class FvUpdateConfirmDialog;
-class FvAvailableUpdate;
-
-
-class FvUpdater : public QObject
-{
-	Q_OBJECT
-
-public:
-
-	// Singleton
-	static FvUpdater* sharedUpdater();
-	static void drop();
-
-	// Set / get feed URL
-	void SetFeedURL(QUrl feedURL);
-	void SetFeedURL(QString feedURL);
-	QString GetFeedURL();
-	void finishUpdate(QString pathToFinish = "");
-	void setRequiredSslFingerPrint(QString md5);
-	QString getRequiredSslFingerPrint();	// returns md5!
-	// HTTP Authentuication - for security reasons no getters are provided, only a setter
-	void setHtAuthCredentials(QString user, QString pass);
-	void setHtAuthUsername(QString user);
-	void setHtAuthPassword(QString pass);
-	void setSkipVersionAllowed(bool allowed);
-	void setRemindLaterAllowed(bool allowed);
-	bool getSkipVersionAllowed();
-	bool getRemindLaterAllowed();
-
-	
-public slots:
-
-	// Check for updates
-	bool CheckForUpdates(bool silentAsMuchAsItCouldGet = true);
-
-	// Aliases
-	bool CheckForUpdatesSilent();
-	bool CheckForUpdatesNotSilent();
-
-
-	//
-	// ---------------------------------------------------
-	// ---------------------------------------------------
-	// ---------------------------------------------------
-	// ---------------------------------------------------
-	//
-
-protected:
-
-	friend class FvUpdateWindow;		// Uses GetProposedUpdate() and others
-	friend class FvUpdateConfirmDialog;	// Uses GetProposedUpdate() and others
-	FvAvailableUpdate* GetProposedUpdate();
-
-
-protected slots:
-
-	// Update window button slots
-	void InstallUpdate();
-	void SkipUpdate();
-	void RemindMeLater();
-
-private:
-
-	//
-	// Singleton business
-	//
-	// (we leave just the declarations, so the compiler will warn us if we try
-	//  to use those two functions by accident)
-	FvUpdater();							// Hide main constructor
-	~FvUpdater();							// Hide main destructor
-	FvUpdater(const FvUpdater&);			// Hide copy constructor
-	FvUpdater& operator=(const FvUpdater&);	// Hide assign op
-
-	static FvUpdater* m_Instance;			// Singleton instance
-
-
-	//
-	// Windows / dialogs
-	//
-#ifdef FV_GUI
-	FvUpdateWindow* m_updaterWindow;								// Updater window (NULL if not shown)
-	void showUpdaterWindowUpdatedWithCurrentUpdateProposal();		// Show updater window
-	void hideUpdaterWindow();										// Hide + destroy m_updaterWindow
-	void updaterWindowWasClosed();									// Sent by the updater window when it gets closed
-#else
-	void decideWhatToDoWithCurrentUpdateProposal();                 // Perform an action which is configured in settings
-#endif
-
-	// Available update (NULL if not fetched)
-	FvAvailableUpdate* m_proposedUpdate;
-
-	// If true, don't show the error dialogs and the "no updates." dialog
-	// (silentAsMuchAsItCouldGet from CheckForUpdates() goes here)
-	// Useful for automatic update checking upon application startup.
-	bool m_silentAsMuchAsItCouldGet;
-
-	// Dialogs (notifications)
-	bool skipVersionAllowed;
-	bool remindLaterAllowed;
-
-	void showErrorDialog(QString message, bool showEvenInSilentMode = false);			// Show an error message
-	void showInformationDialog(QString message, bool showEvenInSilentMode = false);		// Show an informational message
-
-
-	//
-	// HTTP feed fetcher infrastructure
-	//
-	QUrl m_feedURL;					// Feed URL that will be fetched
-	QNetworkAccessManager m_qnam;
-	QNetworkReply* m_reply;
-	int m_httpGetId;
-	bool m_httpRequestAborted;
-
-	void startDownloadFeed(QUrl url);	// Start downloading feed
-	void cancelDownloadFeed();			// Stop downloading the current feed
-
-	//
-	// SSL Fingerprint Check infrastructure
-	//
-	QString m_requiredSslFingerprint;
-
-	bool checkSslFingerPrint(QUrl urltoCheck);	// true=ssl Fingerprint accepted, false= ssl Fingerprint NOT accepted
-
-	//
-	// Htauth-Infrastructure
-	//
-	QString htAuthUsername;
-	QString htAuthPassword;
-
-
-	//
-	// XML parser
-	//
-	QXmlStreamReader m_xml;				// XML data collector and parser
-	bool xmlParseFeed();				// Parse feed in m_xml
-	bool searchDownloadedFeedForUpdates(QString xmlTitle,
-										QString xmlLink,
-										QString xmlReleaseNotesLink,
-										QString xmlPubDate,
-										QString xmlEnclosureUrl,
-										QString xmlEnclosureVersion,
-										QString xmlEnclosurePlatform,
-										unsigned long xmlEnclosureLength,
-										QString xmlEnclosureType);
-
-
-	//
-	// Helpers
-	//
-	void installTranslator();			// Initialize translation mechanism
-	void restartApplication();			// Restarts application after update
-
-private slots:
-
-	void authenticationRequired ( QNetworkReply * reply, QAuthenticator * authenticator );
-	void httpFeedReadyRead();
-	void httpFeedUpdateDataReadProgress(qint64 bytesRead,
-										qint64 totalBytes);
-	void httpFeedDownloadFinished();
-
-	//
-	// Download and install Update infrastructure
-	//
-	void httpUpdateDownloadFinished();
-	bool unzipUpdate(const QString & filePath, const QString & extDirPath, const QString & singleFileName = QString(""));	// returns true on success
-
-signals:
-	void updatedFinishedSuccessfully();
-
-};
-
-#endif // FVUPDATER_H

interface/external/fervor/fvupdatewindow.cpp

@@ -1,66 +0,0 @@
-#include "fvupdatewindow.h"
-#include "ui_fvupdatewindow.h"
-#include "fvupdater.h"
-#include "fvavailableupdate.h"
-#include <QApplication>
-#include <QCloseEvent>
-#include <QDebug>
-
-
-FvUpdateWindow::FvUpdateWindow(QWidget *parent, bool skipVersionAllowed, bool remindLaterAllowed) :
-	QWidget(parent, Qt::CustomizeWindowHint),
-	m_ui(new Ui::FvUpdateWindow)
-{
-	m_ui->setupUi(this);
-
-	m_appIconScene = 0;
-
-	if(!skipVersionAllowed)
-		m_ui->skipThisVersionButton->hide();
-	if(!remindLaterAllowed)
-		m_ui->remindMeLaterButton->hide();
-
-	// Delete on close
-	setAttribute(Qt::WA_DeleteOnClose, true);
-
-	// Set the "new version is available" string
-	QString newVersString = m_ui->newVersionIsAvailableLabel->text().arg(QApplication::applicationName());
-	m_ui->newVersionIsAvailableLabel->setText(newVersString);
-
-	// Connect buttons
-	connect(m_ui->installUpdateButton, SIGNAL(clicked()),
-			FvUpdater::sharedUpdater(), SLOT(InstallUpdate()));
-	connect(m_ui->skipThisVersionButton, SIGNAL(clicked()),
-			FvUpdater::sharedUpdater(), SLOT(SkipUpdate()));
-	connect(m_ui->remindMeLaterButton, SIGNAL(clicked()),
-			FvUpdater::sharedUpdater(), SLOT(RemindMeLater()));
-}
-
-FvUpdateWindow::~FvUpdateWindow()
-{
-	m_ui->releaseNotesWebView->stop();
-	delete m_ui;
-}
-
-bool FvUpdateWindow::UpdateWindowWithCurrentProposedUpdate()
-{
-	FvAvailableUpdate* proposedUpdate = FvUpdater::sharedUpdater()->GetProposedUpdate();
-	if (! proposedUpdate) {
-		return false;
-	}
-
-	QString downloadString = m_ui->wouldYouLikeToDownloadLabel->text()
-			.arg(QApplication::applicationName(), proposedUpdate->GetEnclosureVersion(), QApplication::applicationVersion());
-	m_ui->wouldYouLikeToDownloadLabel->setText(downloadString);
-
-	m_ui->releaseNotesWebView->stop();
-	m_ui->releaseNotesWebView->load(proposedUpdate->GetReleaseNotesLink());
-
-	return true;
-}
-
-void FvUpdateWindow::closeEvent(QCloseEvent* event)
-{
-	FvUpdater::sharedUpdater()->updaterWindowWasClosed();
-	event->accept();
-}

interface/external/fervor/fvupdatewindow.h

@@ -1,37 +0,0 @@
-#ifndef FVUPDATEWINDOW_H
-#define FVUPDATEWINDOW_H
-
-#if QT_VERSION >= 0x050000
-    #include <QtWidgets/QWidget>
-#else
-    #include <QWidget>
-#endif
-
-class QGraphicsScene;
-
-namespace Ui {
-class FvUpdateWindow;
-}
-
-class FvUpdateWindow : public QWidget
-{
-	Q_OBJECT
-	
-public:
-	explicit FvUpdateWindow(QWidget *parent, bool skipVersionAllowed, bool remindLaterAllowed);
-	~FvUpdateWindow();
-
-	// Update the current update proposal from FvUpdater
-	bool UpdateWindowWithCurrentProposedUpdate();
-
-	void closeEvent(QCloseEvent* event);
-
-private:
-	Ui::FvUpdateWindow*	m_ui;
-	QGraphicsScene* m_appIconScene;
-
-};
-
-#endif // FVUPDATEWINDOW_H
-
-	

interface/external/fervor/fvupdatewindow.ui

@@ -1,129 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>FvUpdateWindow</class>
- <widget class="QWidget" name="FvUpdateWindow">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>640</width>
-    <height>480</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Software Update</string>
-  </property>
-  <layout class="QHBoxLayout" name="horizontalLayout_6">
-   <property name="sizeConstraint">
-    <enum>QLayout::SetFixedSize</enum>
-   </property>
-   <item>
-    <layout class="QVBoxLayout" name="verticalLayout">
-     <item>
-      <widget class="QLabel" name="newVersionIsAvailableLabel">
-       <property name="font">
-        <font>
-         <weight>75</weight>
-         <bold>true</bold>
-        </font>
-       </property>
-       <property name="text">
-        <string>A new version of %1 is available!</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QLabel" name="wouldYouLikeToDownloadLabel">
-       <property name="text">
-        <string>%1 %2 is now available - you have %3. Would you like to download it now?</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox">
-       <property name="font">
-        <font>
-         <weight>75</weight>
-         <bold>true</bold>
-        </font>
-       </property>
-       <property name="title">
-        <string>Release Notes:</string>
-       </property>
-       <layout class="QHBoxLayout" name="horizontalLayout_7">
-        <item>
-         <widget class="QWebView" name="releaseNotesWebView">
-          <property name="minimumSize">
-           <size>
-            <width>160</width>
-            <height>80</height>
-           </size>
-          </property>
-          <property name="url">
-           <url>
-            <string>about:blank</string>
-           </url>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <layout class="QHBoxLayout" name="horizontalLayout_3">
-       <item>
-        <widget class="QPushButton" name="skipThisVersionButton">
-         <property name="text">
-          <string>Skip This Version</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <spacer name="horizontalSpacer">
-         <property name="orientation">
-          <enum>Qt::Horizontal</enum>
-         </property>
-         <property name="sizeHint" stdset="0">
-          <size>
-           <width>40</width>
-           <height>20</height>
-          </size>
-         </property>
-        </spacer>
-       </item>
-       <item>
-        <widget class="QPushButton" name="remindMeLaterButton">
-         <property name="text">
-          <string>Remind Me Later</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QPushButton" name="installUpdateButton">
-         <property name="text">
-          <string>Install Update</string>
-         </property>
-         <property name="autoDefault">
-          <bool>true</bool>
-         </property>
-         <property name="default">
-          <bool>true</bool>
-         </property>
-        </widget>
-       </item>
-      </layout>
-     </item>
-    </layout>
-   </item>
-  </layout>
- </widget>
- <customwidgets>
-  <customwidget>
-   <class>QWebView</class>
-   <extends>QWidget</extends>
-   <header>QtWebKit/QWebView</header>
-  </customwidget>
- </customwidgets>
- <resources/>
- <connections/>
-</ui>

interface/external/fervor/fvversioncomparator.cpp

@@ -1,164 +0,0 @@
-#include "fvversioncomparator.h"
-#include <string>
-#include <algorithm>
-#include <cctype>
-
-//
-// Clone of Sparkle's SUStandardVersionComparator.m, so here's original author's
-// copyright too:
-//
-//	Copyright 2007 Andy Matuschak. All rights reserved.
-//
-// Everything's the same except for TypeOfCharacter()
-// (because who knows how Foundation does isdigit() and such.)
-//
-
-
-FvVersionComparator::FvVersionComparator()
-{
-	// noop
-}
-
-FvVersionComparator::CharacterType FvVersionComparator::TypeOfCharacter(std::string character)
-{
-	if (character == ".") {
-		return kSeparatorType;
-	} else if (isdigit(character[0])) {
-		return kNumberType;
-	} else if (isspace(character[0])) {
-		return kSeparatorType;
-	} else if (ispunct(character[0])) {
-		return kSeparatorType;
-	} else {
-		return kStringType;
-	}
-
-}
-
-std::vector<std::string> FvVersionComparator::SplitVersionString(std::string version)
-{
-	std::string character;
-	std::string s;
-	unsigned long i = 0, n = 0;
-	CharacterType oldType, newType;
-	std::vector<std::string> parts;
-
-	if (version.length() == 0) {
-		// Nothing to do here
-		return parts;
-	}
-
-	s = version.substr(0, 1);
-	oldType = TypeOfCharacter(s);
-	n = version.length() - 1;
-	for (i = 1; i <= n; ++i) {
-		character = version.substr(i, 1)[0];
-		newType = TypeOfCharacter(character);
-		if (oldType != newType || oldType == kSeparatorType) {
-			// We've reached a new segment
-			std::string aPart = s;
-			parts.push_back(aPart);
-			s = character;
-		} else {
-			// Add character to string and continue
-			s.append(character);
-		}
-		oldType = newType;
-	}
-
-	// Add the last part onto the array
-	parts.push_back(s);
-	return parts;
-}
-
-
-FvVersionComparator::ComparatorResult FvVersionComparator::CompareVersions(std::string versionA,
-																		   std::string versionB)
-{
-	std::vector<std::string> partsA = SplitVersionString(versionA);
-	std::vector<std::string> partsB = SplitVersionString(versionB);
-
-	std::string partA = std::string(""), partB = std::string("");
-	unsigned long i = 0, n = 0;
-	int intA, intB;
-	CharacterType typeA, typeB;
-
-	n = std::min(partsA.size(), partsB.size());
-	for (i = 0; i < n; ++i) {
-		partA = partsA.at(i);
-		partB = partsB.at(i);
-
-		typeA = TypeOfCharacter(partA);
-		typeB = TypeOfCharacter(partB);
-
-		// Compare types
-		if (typeA == typeB) {
-			// Same type; we can compare
-			if (typeA == kNumberType) {
-				intA = atoi(partA.c_str());
-				intB = atoi(partB.c_str());
-
-				if (intA > intB) {
-					return kDescending;
-				} else if (intA < intB) {
-					return kAscending;
-				}
-			} else if (typeA == kStringType) {
-				short result = partA.compare(partB);
-				switch (result) {
-					case -1: return kAscending; break;
-					case 1: return kDescending; break;
-					case 0: /* do nothing */ break;
-				};
-			}
-		} else {
-			// Not the same type? Now we have to do some validity checking
-			if (typeA != kStringType && typeB == kStringType) {
-				// typeA wins
-				return kDescending;
-			} else if (typeA == kStringType && typeB != kStringType) {
-				// typeB wins
-				return kAscending;
-			} else {
-				// One is a number and the other is a period. The period is invalid
-				if (typeA == kNumberType) {
-					return kDescending;
-				} else {
-					return kAscending;
-				}
-			}
-		}
-	}
-	// The versions are equal up to the point where they both still have parts
-	// Lets check to see if one is larger than the other
-	if (partsA.size() != partsB.size()) {
-		// Yep. Lets get the next part of the larger
-		// n holds the index of the part we want.
-		std::string missingPart = std::string("");
-		CharacterType missingType;
-		ComparatorResult shorterResult, largerResult;
-
-		if (partsA.size() > partsB.size()) {
-			missingPart = partsA.at(n);
-			shorterResult = kAscending;
-			largerResult = kDescending;
-		} else {
-			missingPart = partsB.at(n);
-			shorterResult = kDescending;
-			largerResult = kAscending;
-		}
-
-		missingType = TypeOfCharacter(missingPart);
-		// Check the type
-		if (missingType == kStringType) {
-			// It's a string. Shorter version wins
-			return shorterResult;
-		} else {
-			// It's a number/period. Larger version wins
-			return largerResult;
-		}
-	}
-
-	// The 2 strings are identical
-	return kSame;
-}

interface/external/fervor/fvversioncomparator.h

@@ -1,36 +0,0 @@
-#ifndef FVVERSIONCOMPARATOR_H
-#define FVVERSIONCOMPARATOR_H
-
-#include <iosfwd>
-#include <vector>
-
-
-class FvVersionComparator
-{
-public:
-
-	typedef enum {
-		kSame = 0,
-		kDescending = 1,
-		kAscending = -1
-	} ComparatorResult;
-
-	static ComparatorResult CompareVersions(std::string versionA,
-											std::string versionB);
-
-private:
-
-	FvVersionComparator();
-
-	typedef enum {
-		kNumberType,
-		kStringType,
-		kSeparatorType
-	} CharacterType;
-
-	static CharacterType TypeOfCharacter(std::string character);
-	static std::vector<std::string> SplitVersionString(std::string version);
-
-};
-
-#endif // FVVERSIONCOMPARATOR_H

interface/external/quazip/include/JlCompress.h

@@ -1,114 +0,0 @@
-#ifndef JLCOMPRESSFOLDER_H_
-#define JLCOMPRESSFOLDER_H_
-
-#include "quazip.h"
-#include "quazipfile.h"
-#include "quazipfileinfo.h"
-#include <QString>
-#include <QDir>
-#include <QFileInfo>
-#include <QFile>
-
-/// Utility class for typical operations.
-/**
-  This class contains a number of useful static functions to perform
-  simple operations, such as mass ZIP packing or extraction.
-  */
-class QUAZIP_EXPORT JlCompress {
-private:
-    /// Compress a single file.
-    /**
-      \param zip Opened zip to compress the file to.
-      \param fileName The full path to the source file.
-      \param fileDest The full name of the file inside the archive.
-      \return true if success, false otherwise.
-      */
-    static bool compressFile(QuaZip* zip, QString fileName, QString fileDest);
-    /// Compress a subdirectory.
-    /**
-      \param parentZip Opened zip containing the parent directory.
-      \param dir The full path to the directory to pack.
-      \param parentDir The full path to the directory corresponding to
-      the root of the ZIP.
-      \param recursive Whether to pack sub-directories as well or only
-      files.
-      \return true if success, false otherwise.
-      */
-    static bool compressSubDir(QuaZip* parentZip, QString dir, QString parentDir, bool recursive = true);
-    /// Extract a single file.
-    /**
-      \param zip The opened zip archive to extract from.
-      \param fileName The full name of the file to extract.
-      \param fileDest The full path to the destination file.
-      \return true if success, false otherwise.
-      */
-    static bool extractFile(QuaZip* zip, QString fileName, QString fileDest);
-    /// Remove some files.
-    /**
-      \param listFile The list of files to remove.
-      \return true if success, false otherwise.
-      */
-    static bool removeFile(QStringList listFile);
-
-public:
-    /// Compress a single file.
-    /**
-      \param fileCompressed The name of the archive.
-      \param file The file to compress.
-      \return true if success, false otherwise.
-      */
-    static bool compressFile(QString fileCompressed, QString file);
-    /// Compress a list of files.
-    /**
-      \param fileCompressed The name of the archive.
-      \param files The file list to compress.
-      \return true if success, false otherwise.
-      */
-    static bool compressFiles(QString fileCompressed, QStringList files);
-    /// Compress a whole directory.
-    /**
-      \param fileCompressed The name of the archive.
-      \param dir The directory to compress.
-      \param recursive Whether to pack the subdirectories as well, or
-      just regular files.
-      \return true if success, false otherwise.
-      */
-    static bool compressDir(QString fileCompressed, QString dir = QString(), bool recursive = true);
-
-public:
-    /// Extract a single file.
-    /**
-      \param fileCompressed The name of the archive.
-      \param fileName The file to extract.
-      \param fileDest The destination file, assumed to be identical to
-      \a file if left empty.
-      \return The list of the full paths of the files extracted, empty on failure.
-      */
-    static QString extractFile(QString fileCompressed, QString fileName, QString fileDest = QString());
-    /// Extract a list of files.
-    /**
-      \param fileCompressed The name of the archive.
-      \param files The file list to extract.
-      \param dir The directory to put the files to, the current
-      directory if left empty.
-      \return The list of the full paths of the files extracted, empty on failure.
-      */
-    static QStringList extractFiles(QString fileCompressed, QStringList files, QString dir = QString());
-    /// Extract a whole archive.
-    /**
-      \param fileCompressed The name of the archive.
-      \param dir The directory to extract to, the current directory if
-      left empty.
-      \return The list of the full paths of the files extracted, empty on failure.
-      */
-    static QStringList extractDir(QString fileCompressed, QString dir = QString());
-    /// Get the file list.
-    /**
-      \return The list of the files in the archive, or, more precisely, the
-      list of the entries, including both files and directories if they
-      are present separately.
-      */
-    static QStringList getFileList(QString fileCompressed);
-};
-
-#endif /* JLCOMPRESSFOLDER_H_ */

interface/external/quazip/include/crypt.h

@@ -1,135 +0,0 @@
-/* crypt.h -- base code for crypt/uncrypt ZIPfile
-
-
-   Version 1.01e, February 12th, 2005
-
-   Copyright (C) 1998-2005 Gilles Vollant
-
-   This code is a modified version of crypting code in Infozip distribution
-
-   The encryption/decryption parts of this source code (as opposed to the
-   non-echoing password parts) were originally written in Europe.  The
-   whole source package can be freely distributed, including from the USA.
-   (Prior to January 2000, re-export from the US was a violation of US law.)
-
-   This encryption code is a direct transcription of the algorithm from
-   Roger Schlafly, described by Phil Katz in the file appnote.txt.  This
-   file (appnote.txt) is distributed with the PKZIP program (even in the
-   version without encryption capabilities).
-
-   If you don't need crypting in your application, just define symbols
-   NOCRYPT and NOUNCRYPT.
-
-   This code support the "Traditional PKWARE Encryption".
-
-   The new AES encryption added on Zip format by Winzip (see the page
-   http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
-   Encryption is not supported.
-*/
-
-#include "quazip_global.h"
-
-#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
-
-/***********************************************************************
- * Return the next byte in the pseudo-random sequence
- */
-static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab UNUSED)
-{
-    //(void) pcrc_32_tab; /* avoid "unused parameter" warning */
-    unsigned temp;  /* POTENTIAL BUG:  temp*(temp^1) may overflow in an
-                     * unpredictable manner on 16-bit systems; not a problem
-                     * with any known compiler so far, though */
-
-    temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
-    return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
-}
-
-/***********************************************************************
- * Update the encryption keys with the next byte of plain text
- */
-static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
-{
-    (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
-    (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
-    (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
-    {
-      register int keyshift = (int)((*(pkeys+1)) >> 24);
-      (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
-    }
-    return c;
-}
-
-
-/***********************************************************************
- * Initialize the encryption keys and the random header according to
- * the given password.
- */
-static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
-{
-    *(pkeys+0) = 305419896L;
-    *(pkeys+1) = 591751049L;
-    *(pkeys+2) = 878082192L;
-    while (*passwd != '\0') {
-        update_keys(pkeys,pcrc_32_tab,(int)*passwd);
-        passwd++;
-    }
-}
-
-#define zdecode(pkeys,pcrc_32_tab,c) \
-    (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
-
-#define zencode(pkeys,pcrc_32_tab,c,t) \
-    (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
-
-#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
-
-#define RAND_HEAD_LEN  12
-   /* "last resort" source for second part of crypt seed pattern */
-#  ifndef ZCR_SEED2
-#    define ZCR_SEED2 3141592654UL     /* use PI as default pattern */
-#  endif
-
-static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
-    const char *passwd;         /* password string */
-    unsigned char *buf;         /* where to write header */
-    int bufSize;
-    unsigned long* pkeys;
-    const unsigned long* pcrc_32_tab;
-    unsigned long crcForCrypting;
-{
-    int n;                       /* index in random header */
-    int t;                       /* temporary */
-    int c;                       /* random byte */
-    unsigned char header[RAND_HEAD_LEN-2]; /* random header */
-    static unsigned calls = 0;   /* ensure different random header each time */
-
-    if (bufSize<RAND_HEAD_LEN)
-      return 0;
-
-    /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
-     * output of rand() to get less predictability, since rand() is
-     * often poorly implemented.
-     */
-    if (++calls == 1)
-    {
-        srand((unsigned)(time(NULL) ^ ZCR_SEED2));
-    }
-    init_keys(passwd, pkeys, pcrc_32_tab);
-    for (n = 0; n < RAND_HEAD_LEN-2; n++)
-    {
-        c = (rand() >> 7) & 0xff;
-        header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
-    }
-    /* Encrypt random header (last two bytes is high word of crc) */
-    init_keys(passwd, pkeys, pcrc_32_tab);
-    for (n = 0; n < RAND_HEAD_LEN-2; n++)
-    {
-        buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
-    }
-    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
-    buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
-    return n;
-}
-
-#endif

interface/external/quazip/include/ioapi.h

@@ -1,77 +0,0 @@
-/* ioapi.h -- IO base function header for compress/uncompress .zip
-   files using zlib + zip or unzip API
-
-   Version 1.01e, February 12th, 2005
-
-   Copyright (C) 1998-2005 Gilles Vollant
-
-   Modified by Sergey A. Tachenov to integrate with Qt.
-*/
-
-#ifndef _ZLIBIOAPI_H
-#define _ZLIBIOAPI_H
-
-
-#define ZLIB_FILEFUNC_SEEK_CUR (1)
-#define ZLIB_FILEFUNC_SEEK_END (2)
-#define ZLIB_FILEFUNC_SEEK_SET (0)
-
-#define ZLIB_FILEFUNC_MODE_READ      (1)
-#define ZLIB_FILEFUNC_MODE_WRITE     (2)
-#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
-
-#define ZLIB_FILEFUNC_MODE_EXISTING (4)
-#define ZLIB_FILEFUNC_MODE_CREATE   (8)
-
-
-#ifndef ZCALLBACK
-
-#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
-#define ZCALLBACK CALLBACK
-#else
-#define ZCALLBACK
-#endif
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, voidpf file, int mode));
-typedef uLong  (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
-typedef uLong  (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
-typedef uLong   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
-typedef int   (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
-typedef int    (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
-typedef int    (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
-
-typedef struct zlib_filefunc_def_s
-{
-    open_file_func      zopen_file;
-    read_file_func      zread_file;
-    write_file_func     zwrite_file;
-    tell_file_func      ztell_file;
-    seek_file_func      zseek_file;
-    close_file_func     zclose_file;
-    testerror_file_func zerror_file;
-    voidpf              opaque;
-} zlib_filefunc_def;
-
-
-
-void fill_qiodevice_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
-
-#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
-#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
-#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
-#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
-#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
-#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-

interface/external/quazip/include/quaadler32.h

@@ -1,29 +0,0 @@
-#ifndef QUAADLER32_H
-#define QUAADLER32_H
-
-#include <QByteArray>
-
-#include "quachecksum32.h"
-
-/// Adler32 checksum
-/** \class QuaAdler32 quaadler32.h <quazip/quaadler32.h>
- * This class wrappers the adler32 function with the QuaChecksum32 interface.
- * See QuaChecksum32 for more info.
- */
-class QUAZIP_EXPORT QuaAdler32 : public QuaChecksum32
-{
-
-public:
-	QuaAdler32();
-
-	quint32 calculate(const QByteArray &data);
-
-	void reset();
-	void update(const QByteArray &buf);
-	quint32 value();
-
-private:
-	quint32 checksum;
-};
-
-#endif //QUAADLER32_H

interface/external/quazip/include/quachecksum32.h

@@ -1,54 +0,0 @@
-#ifndef QUACHECKSUM32_H
-#define QUACHECKSUM32_H
-
-#include <QByteArray>
-#include "quazip_global.h"
-
-/// Checksum interface.
-/** \class QuaChecksum32 quachecksum32.h <quazip/quachecksum32.h>
- * This is an interface for 32 bit checksums.
- * Classes implementing this interface can calcunate a certin
- * checksum in a single step:
- * \code
- * QChecksum32 *crc32 = new QuaCrc32(); 
- * rasoult = crc32->calculate(data);
- * \endcode
- * or by streaming the data:
- * \code
- * QChecksum32 *crc32 = new QuaCrc32(); 
- * while(!fileA.atEnd())
- *     crc32->update(fileA.read(bufSize));
- * resoultA = crc32->value();
- * crc32->reset();
- * while(!fileB.atEnd())
- *     crc32->update(fileB.read(bufSize));
- * resoultB = crc32->value();
- * \endcode
- */
-class QUAZIP_EXPORT QuaChecksum32
-{
-
-public:
-	///Calculates the checksum for data.
-	/** \a data source data
-	 * \return data checksum
-	 *
-	 * This function has no efect on the value returned by value().
-	 */
-	virtual quint32 calculate(const QByteArray &data) = 0;
-
-	///Resets the calculation on a checksun for a stream.
-	virtual void reset() = 0;
-
-	///Updates the calculated checksum for the stream
-	/** \a buf next portion of data from the stream
-	 */
-	virtual void update(const QByteArray &buf) = 0;
-
-	///Value of the checksum calculated for the stream passed throw update().
-	/** \return checksum
-	 */
-	virtual quint32 value() = 0;
-};
-
-#endif //QUACHECKSUM32_H

interface/external/quazip/include/quacrc32.h

@@ -1,26 +0,0 @@
-#ifndef QUACRC32_H
-#define QUACRC32_H
-
-#include "quachecksum32.h"
-
-///CRC32 checksum
-/** \class QuaCrc32 quacrc32.h <quazip/quacrc32.h>
-* This class wrappers the crc32 function with the QuaChecksum32 interface.
-* See QuaChecksum32 for more info.
-*/
-class QUAZIP_EXPORT QuaCrc32 : public QuaChecksum32 {
-
-public:
-	QuaCrc32();
-
-	quint32 calculate(const QByteArray &data);
-
-	void reset();
-	void update(const QByteArray &buf);
-	quint32 value();
-
-private:
-	quint32 checksum;
-};
-
-#endif //QUACRC32_H

interface/external/quazip/include/quagzipfile.h

@@ -1,84 +0,0 @@
-#ifndef QUAZIP_QUAGZIPFILE_H
-#define QUAZIP_QUAGZIPFILE_H
-
-#include <QIODevice>
-#include "quazip_global.h"
-
-#include <zlib.h>
-
-class QuaGzipFilePrivate;
-
-/// GZIP file
-/**
-  This class is a wrapper around GZIP file access functions in zlib. Unlike QuaZip classes, it doesn't allow reading from a GZIP file opened as QIODevice, for example, if your GZIP file is in QBuffer. It only provides QIODevice access to a GZIP file contents, but the GZIP file itself must be identified by its name on disk or by descriptor id.
-  */
-class QUAZIP_EXPORT QuaGzipFile: public QIODevice {
-  Q_OBJECT
-public:
-  /// Empty constructor.
-  /**
-    Must call setFileName() before trying to open.
-    */
-  QuaGzipFile();
-  /// Empty constructor with a parent.
-  /**
-    Must call setFileName() before trying to open.
-    \param parent The parent object, as per QObject logic.
-    */
-  QuaGzipFile(QObject *parent);
-  /// Constructor.
-  /**
-    \param fileName The name of the GZIP file.
-    \param parent The parent object, as per QObject logic.
-    */
-  QuaGzipFile(const QString &fileName, QObject *parent = NULL);
-  /// Destructor.
-  virtual ~QuaGzipFile();
-  /// Sets the name of the GZIP file to be opened.
-  void setFileName(const QString& fileName);
-  /// Returns the name of the GZIP file.
-  QString getFileName() const;
-  /// Returns true.
-  /**
-    Strictly speaking, zlib supports seeking for GZIP files, but it is
-    poorly implemented, because there is no way to implement it
-    properly. For reading, seeking backwards is very slow, and for
-    writing, it is downright impossible. Therefore, QuaGzipFile does not
-    support seeking at all.
-    */
-  virtual bool isSequential() const;
-  /// Opens the file.
-  /**
-    \param mode Can be either QIODevice::Write or QIODevice::Read.
-    ReadWrite and Append aren't supported.
-    */
-  virtual bool open(QIODevice::OpenMode mode);
-  /// Opens the file.
-  /**
-    \overload
-    \param fd The file descriptor to read/write the GZIP file from/to.
-    \param mode Can be either QIODevice::Write or QIODevice::Read.
-    ReadWrite and Append aren't supported.
-    */
-  virtual bool open(int fd, QIODevice::OpenMode mode);
-  /// Flushes data to file.
-  /**
-    The data is written using Z_SYNC_FLUSH mode. Doesn't make any sense
-    when reading.
-    */
-  virtual bool flush();
-  /// Closes the file.
-  virtual void close();
-protected:
-  /// Implementation of QIODevice::readData().
-  virtual qint64 readData(char *data, qint64 maxSize);
-  /// Implementation of QIODevice::writeData().
-  virtual qint64 writeData(const char *data, qint64 maxSize);
-private:
-    // not implemented by design to disable copy
-    QuaGzipFile(const QuaGzipFile &that);
-    QuaGzipFile& operator=(const QuaGzipFile &that);
-    QuaGzipFilePrivate *d;
-};
-
-#endif // QUAZIP_QUAGZIPFILE_H

interface/external/quazip/include/quaziodevice.h

@@ -1,74 +0,0 @@
-#ifndef QUAZIP_QUAZIODEVICE_H
-#define QUAZIP_QUAZIODEVICE_H
-
-#include <QIODevice>
-#include "quazip_global.h"
-
-#include <zlib.h>
-
-class QuaZIODevicePrivate;
-
-/// A class to compress/decompress QIODevice.
-/**
-  This class can be used to compress any data written to QIODevice or
-  decompress it back. Compressing data sent over a QTcpSocket is a good
-  example.
-  */
-class QUAZIP_EXPORT QuaZIODevice: public QIODevice {
-  Q_OBJECT
-public:
-  /// Constructor.
-  /**
-    \param io The QIODevice to read/write.
-    \param parent The parent object, as per QObject logic.
-    */
-  QuaZIODevice(QIODevice *io, QObject *parent = NULL);
-  /// Destructor.
-  ~QuaZIODevice();
-  /// Flushes data waiting to be written.
-  /**
-    Unfortunately, as QIODevice doesn't support flush() by itself, the
-    only thing this method does is write the compressed data into the
-    device using Z_SYNC_FLUSH mode. If you need the compressed data to
-    actually be flushed from the buffer of the underlying QIODevice, you
-    need to call its flush() method as well, providing it supports it
-    (like QTcpSocket does). Example:
-    \code
-    QuaZIODevice dev(&sock);
-    dev.open(QIODevice::Write);
-    dev.write(yourDataGoesHere);
-    dev.flush();
-    sock->flush(); // this actually sends data to network
-    \endcode
-
-    This may change in the future versions of QuaZIP by implementing an
-    ugly hack: trying to cast the QIODevice using qobject_cast to known
-    flush()-supporting subclasses, and calling flush if the resulting
-    pointer is not zero.
-    */
-  virtual bool flush();
-  /// Opens the device.
-  /**
-    \param mode Neither QIODevice::ReadWrite nor QIODevice::Append are
-    not supported.
-    */
-  virtual bool open(QIODevice::OpenMode mode);
-  /// Closes this device, but not the underlying one.
-  /**
-    The underlying QIODevice is not closed in case you want to write
-    something else to it.
-    */
-  virtual void close();
-  /// Returns the underlying device.
-  QIODevice *getIoDevice() const;
-  /// Returns true.
-  virtual bool isSequential() const;
-protected:
-  /// Implementation of QIODevice::readData().
-  virtual qint64 readData(char *data, qint64 maxSize);
-  /// Implementation of QIODevice::writeData().
-  virtual qint64 writeData(const char *data, qint64 maxSize);
-private:
-  QuaZIODevicePrivate *d;
-};
-#endif // QUAZIP_QUAZIODEVICE_H

interface/external/quazip/include/quazip.h

@@ -1,419 +0,0 @@
-#ifndef QUA_ZIP_H
-#define QUA_ZIP_H
-
-/*
-Copyright (C) 2005-2011 Sergey A. Tachenov
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
-your option) any later version.
-
-This program is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
-General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with this program; if not, write to the Free Software Foundation,
-Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-See COPYING file for the full LGPL text.
-
-Original ZIP package is copyrighted by Gilles Vollant, see
-quazip/(un)zip.h files for details, basically it's zlib license.
- **/
-
-#include <QString>
-#include <QStringList>
-#include <QTextCodec>
-
-#include "zip.h"
-#include "unzip.h"
-
-#include "quazip_global.h"
-#include "quazipfileinfo.h"
-
-// just in case it will be defined in the later versions of the ZIP/UNZIP
-#ifndef UNZ_OPENERROR
-// define additional error code
-#define UNZ_OPENERROR -1000
-#endif
-
-class QuaZipPrivate;
-
-/// ZIP archive.
-/** \class QuaZip quazip.h <quazip/quazip.h>
- * This class implements basic interface to the ZIP archive. It can be
- * used to read table contents of the ZIP archive and retreiving
- * information about the files inside it.
- *
- * You can also use this class to open files inside archive by passing
- * pointer to the instance of this class to the constructor of the
- * QuaZipFile class. But see QuaZipFile::QuaZipFile(QuaZip*, QObject*)
- * for the possible pitfalls.
- *
- * This class is indended to provide interface to the ZIP subpackage of
- * the ZIP/UNZIP package as well as to the UNZIP subpackage. But
- * currently it supports only UNZIP.
- *
- * The use of this class is simple - just create instance using
- * constructor, then set ZIP archive file name using setFile() function
- * (if you did not passed the name to the constructor), then open() and
- * then use different functions to work with it! Well, if you are
- * paranoid, you may also wish to call close before destructing the
- * instance, to check for errors on close.
- *
- * You may also use getUnzFile() and getZipFile() functions to get the
- * ZIP archive handle and use it with ZIP/UNZIP package API directly.
- *
- * This class supports localized file names inside ZIP archive, but you
- * have to set up proper codec with setCodec() function. By default,
- * locale codec will be used, which is probably ok for UNIX systems, but
- * will almost certainly fail with ZIP archives created in Windows. This
- * is because Windows ZIP programs have strange habit of using DOS
- * encoding for file names in ZIP archives. For example, ZIP archive
- * with cyrillic names created in Windows will have file names in \c
- * IBM866 encoding instead of \c WINDOWS-1251. I think that calling one
- * function is not much trouble, but for true platform independency it
- * would be nice to have some mechanism for file name encoding auto
- * detection using locale information. Does anyone know a good way to do
- * it?
- **/
-class QUAZIP_EXPORT QuaZip {
-  friend class QuaZipPrivate;
-  public:
-    /// Useful constants.
-    enum Constants {
-      MAX_FILE_NAME_LENGTH=256 /**< Maximum file name length. Taken from
-                                 \c UNZ_MAXFILENAMEINZIP constant in
-                                 unzip.c. */
-    };
-    /// Open mode of the ZIP file.
-    enum Mode {
-      mdNotOpen, ///< ZIP file is not open. This is the initial mode.
-      mdUnzip, ///< ZIP file is open for reading files inside it.
-      mdCreate, ///< ZIP file was created with open() call.
-      mdAppend, /**< ZIP file was opened in append mode. This refers to
-                  * \c APPEND_STATUS_CREATEAFTER mode in ZIP/UNZIP package
-                  * and means that zip is appended to some existing file
-                  * what is useful when that file contains
-                  * self-extractor code. This is obviously \em not what
-                  * you whant to use to add files to the existing ZIP
-                  * archive.
-                  **/
-      mdAdd ///< ZIP file was opened for adding files in the archive.
-    };
-    /// Case sensitivity for the file names.
-    /** This is what you specify when accessing files in the archive.
-     * Works perfectly fine with any characters thanks to Qt's great
-     * unicode support. This is different from ZIP/UNZIP API, where
-     * only US-ASCII characters was supported.
-     **/
-    enum CaseSensitivity {
-      csDefault=0, ///< Default for platform. Case sensitive for UNIX, not for Windows.
-      csSensitive=1, ///< Case sensitive.
-      csInsensitive=2 ///< Case insensitive.
-    };
-    /// Returns the actual case sensitivity for the specified QuaZIP one.
-    /**
-      \param cs The value to convert.
-      \returns If CaseSensitivity::csDefault, then returns the default
-      file name case sensitivity for the platform. Otherwise, just
-      returns the appropriate value from the Qt::CaseSensitivity enum.
-      */
-    static Qt::CaseSensitivity convertCaseSensitivity(
-            CaseSensitivity cs);
-  private:
-    QuaZipPrivate *p;
-    // not (and will not be) implemented
-    QuaZip(const QuaZip& that);
-    // not (and will not be) implemented
-    QuaZip& operator=(const QuaZip& that);
-  public:
-    /// Constructs QuaZip object.
-    /** Call setName() before opening constructed object. */
-    QuaZip();
-    /// Constructs QuaZip object associated with ZIP file \a zipName.
-    QuaZip(const QString& zipName);
-    /// Constructs QuaZip object associated with ZIP file represented by \a ioDevice.
-    /** The IO device must be seekable, otherwise an error will occur when opening. */
-    QuaZip(QIODevice *ioDevice);
-    /// Destroys QuaZip object.
-    /** Calls close() if necessary. */
-    ~QuaZip();
-    /// Opens ZIP file.
-    /**
-     * Argument \a mode specifies open mode of the ZIP archive. See Mode
-     * for details. Note that there is zipOpen2() function in the
-     * ZIP/UNZIP API which accepts \a globalcomment argument, but it
-     * does not use it anywhere, so this open() function does not have this
-     * argument. See setComment() if you need to set global comment.
-     *
-     * If the ZIP file is accessed via explicitly set QIODevice, then
-     * this device is opened in the necessary mode. If the device was
-     * already opened by some other means, then the behaviour is defined by
-     * the device implementation, but generally it is not a very good
-     * idea. For example, QFile will at least issue a warning.
-     *
-     * \return \c true if successful, \c false otherwise.
-     *
-     * \note ZIP/UNZIP API open calls do not return error code - they
-     * just return \c NULL indicating an error. But to make things
-     * easier, quazip.h header defines additional error code \c
-     * UNZ_ERROROPEN and getZipError() will return it if the open call
-     * of the ZIP/UNZIP API returns \c NULL.
-     *
-     * Argument \a ioApi specifies IO function set for ZIP/UNZIP
-     * package to use. See unzip.h, zip.h and ioapi.h for details. Note
-     * that IO API for QuaZip is different from the original package.
-     * The file path argument was changed to be of type \c voidpf, and
-     * QuaZip passes a QIODevice pointer there. This QIODevice is either
-     * set explicitly via setIoDevice() or the QuaZip(QIODevice*)
-     * constructor, or it is created internally when opening the archive
-     * by its file name. The default API (qioapi.cpp) just delegates
-     * everything to the QIODevice API. Not only this allows to use a
-     * QIODevice instead of file name, but also has a nice side effect
-     * of raising the file size limit from 2G to 4G.
-     *
-     * In short: just forget about the \a ioApi argument and you'll be
-     * fine.
-     **/
-    bool open(Mode mode, zlib_filefunc_def *ioApi =NULL);
-    /// Closes ZIP file.
-    /** Call getZipError() to determine if the close was successful. The
-     * underlying QIODevice is also closed, regardless of whether it was
-     * set explicitly or not. */
-    void close();
-    /// Sets the codec used to encode/decode file names inside archive.
-    /** This is necessary to access files in the ZIP archive created
-     * under Windows with non-latin characters in file names. For
-     * example, file names with cyrillic letters will be in \c IBM866
-     * encoding.
-     **/
-    void setFileNameCodec(QTextCodec *fileNameCodec);
-    /// Sets the codec used to encode/decode file names inside archive.
-    /** \overload
-     * Equivalent to calling setFileNameCodec(QTextCodec::codecForName(codecName));
-     **/
-    void setFileNameCodec(const char *fileNameCodecName);
-    /// Returns the codec used to encode/decode comments inside archive.
-    QTextCodec* getFileNameCodec() const;
-    /// Sets the codec used to encode/decode comments inside archive.
-    /** This codec defaults to locale codec, which is probably ok.
-     **/
-    void setCommentCodec(QTextCodec *commentCodec);
-    /// Sets the codec used to encode/decode comments inside archive.
-    /** \overload
-     * Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName));
-     **/
-    void setCommentCodec(const char *commentCodecName);
-    /// Returns the codec used to encode/decode comments inside archive.
-    QTextCodec* getCommentCodec() const;
-    /// Returns the name of the ZIP file.
-    /** Returns null string if no ZIP file name has been set, for
-     * example when the QuaZip instance is set up to use a QIODevice
-     * instead.
-     * \sa setZipName(), setIoDevice(), getIoDevice()
-     **/
-    QString getZipName() const;
-    /// Sets the name of the ZIP file.
-    /** Does nothing if the ZIP file is open.
-     *
-     * Does not reset error code returned by getZipError().
-     * \sa setIoDevice(), getIoDevice(), getZipName()
-     **/
-    void setZipName(const QString& zipName);
-    /// Returns the device representing this ZIP file.
-    /** Returns null string if no device has been set explicitly, for
-     * example when opening a ZIP file by name.
-     * \sa setIoDevice(), getZipName(), setZipName()
-     **/
-    QIODevice *getIoDevice() const;
-    /// Sets the device representing the ZIP file.
-    /** Does nothing if the ZIP file is open.
-     *
-     * Does not reset error code returned by getZipError().
-     * \sa getIoDevice(), getZipName(), setZipName()
-     **/
-    void setIoDevice(QIODevice *ioDevice);
-    /// Returns the mode in which ZIP file was opened.
-    Mode getMode() const;
-    /// Returns \c true if ZIP file is open, \c false otherwise.
-    bool isOpen() const;
-    /// Returns the error code of the last operation.
-    /** Returns \c UNZ_OK if the last operation was successful.
-     *
-     * Error code resets to \c UNZ_OK every time you call any function
-     * that accesses something inside ZIP archive, even if it is \c
-     * const (like getEntriesCount()). open() and close() calls reset
-     * error code too. See documentation for the specific functions for
-     * details on error detection.
-     **/
-    int getZipError() const;
-    /// Returns number of the entries in the ZIP central directory.
-    /** Returns negative error code in the case of error. The same error
-     * code will be returned by subsequent getZipError() call.
-     **/
-    int getEntriesCount() const;
-    /// Returns global comment in the ZIP file.
-    QString getComment() const;
-    /// Sets the global comment in the ZIP file.
-    /** The comment will be written to the archive on close operation.
-     * QuaZip makes a distinction between a null QByteArray() comment 
-     * and an empty &quot;&quot; comment in the QuaZip::mdAdd mode. 
-     * A null comment is the default and it means &quot;don't change 
-     * the comment&quot;. An empty comment removes the original comment.
-     *
-     * \sa open()
-     **/
-    void setComment(const QString& comment);
-    /// Sets the current file to the first file in the archive.
-    /** Returns \c true on success, \c false otherwise. Call
-     * getZipError() to get the error code.
-     **/
-    bool goToFirstFile();
-    /// Sets the current file to the next file in the archive.
-    /** Returns \c true on success, \c false otherwise. Call
-     * getZipError() to determine if there was an error.
-     *
-     * Should be used only in QuaZip::mdUnzip mode.
-     *
-     * \note If the end of file was reached, getZipError() will return
-     * \c UNZ_OK instead of \c UNZ_END_OF_LIST_OF_FILE. This is to make
-     * things like this easier:
-     * \code
-     * for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) {
-     *   // do something
-     * }
-     * if(zip.getZipError()==UNZ_OK) {
-     *   // ok, there was no error
-     * }
-     * \endcode
-     **/
-    bool goToNextFile();
-    /// Sets current file by its name.
-    /** Returns \c true if successful, \c false otherwise. Argument \a
-     * cs specifies case sensitivity of the file name. Call
-     * getZipError() in the case of a failure to get error code.
-     *
-     * This is not a wrapper to unzLocateFile() function. That is
-     * because I had to implement locale-specific case-insensitive
-     * comparison.
-     *
-     * Here are the differences from the original implementation:
-     *
-     * - If the file was not found, error code is \c UNZ_OK, not \c
-     *   UNZ_END_OF_LIST_OF_FILE (see also goToNextFile()).
-     * - If this function fails, it unsets the current file rather than
-     *   resetting it back to what it was before the call.
-     *
-     * If \a fileName is null string then this function unsets the
-     * current file and return \c true. Note that you should close the
-     * file first if it is open! See
-     * QuaZipFile::QuaZipFile(QuaZip*,QObject*) for the details.
-     *
-     * Should be used only in QuaZip::mdUnzip mode.
-     *
-     * \sa setFileNameCodec(), CaseSensitivity
-     **/
-    bool setCurrentFile(const QString& fileName, CaseSensitivity cs =csDefault);
-    /// Returns \c true if the current file has been set.
-    bool hasCurrentFile() const;
-    /// Retrieves information about the current file.
-    /** Fills the structure pointed by \a info. Returns \c true on
-     * success, \c false otherwise. In the latter case structure pointed
-     * by \a info remains untouched. If there was an error,
-     * getZipError() returns error code.
-     *
-     * Should be used only in QuaZip::mdUnzip mode.
-     *
-     * Does nothing and returns \c false in any of the following cases.
-     * - ZIP is not open;
-     * - ZIP does not have current file;
-     * - \a info is \c NULL;
-     *
-     * In all these cases getZipError() returns \c UNZ_OK since there
-     * is no ZIP/UNZIP API call.
-     **/
-    bool getCurrentFileInfo(QuaZipFileInfo* info)const;
-    /// Returns the current file name.
-    /** Equivalent to calling getCurrentFileInfo() and then getting \c
-     * name field of the QuaZipFileInfo structure, but faster and more
-     * convenient.
-     *
-     * Should be used only in QuaZip::mdUnzip mode.
-     **/
-    QString getCurrentFileName()const;
-    /// Returns \c unzFile handle.
-    /** You can use this handle to directly call UNZIP part of the
-     * ZIP/UNZIP package functions (see unzip.h).
-     *
-     * \warning When using the handle returned by this function, please
-     * keep in mind that QuaZip class is unable to detect any changes
-     * you make in the ZIP file state (e. g. changing current file, or
-     * closing the handle). So please do not do anything with this
-     * handle that is possible to do with the functions of this class.
-     * Or at least return the handle in the original state before
-     * calling some another function of this class (including implicit
-     * destructor calls and calls from the QuaZipFile objects that refer
-     * to this QuaZip instance!). So if you have changed the current
-     * file in the ZIP archive - then change it back or you may
-     * experience some strange behavior or even crashes.
-     **/
-    unzFile getUnzFile();
-    /// Returns \c zipFile handle.
-    /** You can use this handle to directly call ZIP part of the
-     * ZIP/UNZIP package functions (see zip.h). Warnings about the
-     * getUnzFile() function also apply to this function.
-     **/
-    zipFile getZipFile();
-    /// Changes the data descriptor writing mode.
-    /**
-      According to the ZIP format specification, a file inside archive
-      may have a data descriptor immediately following the file
-      data. This is reflected by a special flag in the local file header
-      and in the central directory. By default, QuaZIP sets this flag
-      and writes the data descriptor unless both method and level were
-      set to 0, in which case it operates in 1.0-compatible mode and
-      never writes data descriptors.
-
-      By setting this flag to false, it is possible to disable data
-      descriptor writing, thus increasing compatibility with archive
-      readers that don't understand this feature of the ZIP file format.
-
-      Setting this flag affects all the QuaZipFile instances that are
-      opened after this flag is set.
-
-      The data descriptor writing mode is enabled by default.
-
-      \param enabled If \c true, enable local descriptor writing,
-      disable it otherwise.
-
-      \sa QuaZipFile::setDataDescriptorWritingEnabled()
-      */
-    void setDataDescriptorWritingEnabled(bool enabled);
-    /// Returns the data descriptor default writing mode.
-    /**
-      \sa setDataDescriptorWritingEnabled()
-      */
-    bool isDataDescriptorWritingEnabled() const;
-    /// Returns a list of files inside the archive.
-    /**
-      \return A list of file names or an empty list if there
-      was an error or if the archive is empty (call getZipError() to
-      figure out which).
-      \sa getFileInfoList()
-      */
-    QStringList getFileNameList() const;
-    /// Returns information list about all files inside the archive.
-    /**
-      \return A list of QuaZipFileInfo objects or an empty list if there
-      was an error or if the archive is empty (call getZipError() to
-      figure out which).
-      \sa getFileNameList()
-      */
-    QList<QuaZipFileInfo> getFileInfoList() const;
-};
-
-#endif

interface/external/quazip/include/quazip_global.h

@@ -1,55 +0,0 @@
-/**
-Copyright (C) 2005-2011 Sergey A. Tachenov
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
-your option) any later version.
-
-This program is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
-General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with this program; if not, write to the Free Software Foundation,
-Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-See COPYING file for the full LGPL text.
-
-Original ZIP package is copyrighted by Gilles Vollant, see
-quazip/(un)zip.h files for details, basically it's zlib license.
- */
-
-#ifndef QUAZIP_GLOBAL_H
-#define QUAZIP_GLOBAL_H
-
-#include <QtCore/qglobal.h>
-
-/**
-  This is automatically defined when building a static library, but when
-  including QuaZip sources directly into a project, QUAZIP_STATIC should
-  be defined explicitly to avoid possible troubles with unnecessary
-  importing/exporting.
-  */
-#ifdef QUAZIP_STATIC
-#define QUAZIP_EXPORT
-#else
-/**
- * When building a DLL with MSVC, QUAZIP_BUILD must be defined.
- * qglobal.h takes care of defining Q_DECL_* correctly for msvc/gcc.
- */
-#if defined(QUAZIP_BUILD)
-	#define QUAZIP_EXPORT Q_DECL_EXPORT
-#else
-	#define QUAZIP_EXPORT Q_DECL_IMPORT
-#endif
-#endif // QUAZIP_STATIC
-
-#ifdef __GNUC__
-#define UNUSED __attribute__((__unused__))
-#else
-#define UNUSED
-#endif
-
-#endif // QUAZIP_GLOBAL_H

interface/external/quazip/include/quazipdir.h

@@ -1,171 +0,0 @@
-#ifndef QUAZIP_QUAZIPDIR_H
-#define QUAZIP_QUAZIPDIR_H
-
-class QuaZipDirPrivate;
-
-#include "quazip.h"
-#include "quazipfileinfo.h"
-#include <QDir>
-#include <QList>
-#include <QSharedDataPointer>
-
-/// Provides ZIP archive navigation.
-/**
-* This class is modelled after QDir, and is designed to provide similar
-* features for ZIP archives.
-*
-* The only significant difference from QDir is that the root path is not
-* '/', but an empty string since that's how the file paths are stored in
-* the archive. However, QuaZipDir understands the paths starting with
-* '/'. It is important in a few places:
-*
-* - In the cd() function.
-* - In the constructor.
-* - In the exists() function.
-*
-* Note that since ZIP uses '/' on all platforms, the '\' separator is
-* not supported.
-*/
-class QUAZIP_EXPORT QuaZipDir {
-private:
-    QSharedDataPointer<QuaZipDirPrivate> d;
-public:
-    /// The copy constructor.
-    QuaZipDir(const QuaZipDir &that);
-    /// Constructs a QuaZipDir instance pointing to the specified directory.
-    /**
-       If \a dir is not specified, points to the root of the archive.
-       The same happens if the \a dir is &quot;/&quot;.
-     */
-    QuaZipDir(QuaZip *zip, const QString &dir = QString());
-    /// Destructor.
-    ~QuaZipDir();
-    /// The assignment operator.
-    bool operator==(const QuaZipDir &that);
-    /// operator!=
-    /**
-      \return \c true if either this and \a that use different QuaZip
-      instances or if they point to different directories.
-      */
-    inline bool operator!=(const QuaZipDir &that) {return !operator==(that);}
-    /// operator==
-    /**
-      \return \c true if both this and \a that use the same QuaZip
-      instance and point to the same directory.
-      */
-    QuaZipDir& operator=(const QuaZipDir &that);
-    /// Returns the name of the entry at the specified position.
-    QString operator[](int pos) const;
-    /// Returns the current case sensitivity mode.
-    QuaZip::CaseSensitivity caseSensitivity() const;
-    /// Changes the 'current' directory.
-    /**
-      * If the path starts with '/', it is interpreted as an absolute
-      * path from the root of the archive. Otherwise, it is interpreted
-      * as a path relative to the current directory as was set by the
-      * previous cd() or the constructor.
-      * 
-      * Note that the subsequent path() call will not return a path
-      * starting with '/' in all cases.
-      */
-    bool cd(const QString &dirName);
-    /// Goes up.
-    bool cdUp();
-    /// Returns the number of entries in the directory.
-    uint count() const;
-    /// Returns the current directory name.
-    /**
-      The name doesn't include the path.
-      */
-    QString dirName() const;
-    /// Returns the list of the entries in the directory.
-    /**
-      \param nameFilters The list of file patterns to list, uses the same
-      syntax as QDir.
-      \param filters The entry type filters, only Files and Dirs are
-      accepted.
-      \param sort Sorting mode (not supported yet).
-      */
-    QList<QuaZipFileInfo> entryInfoList(const QStringList &nameFilters,
-        QDir::Filters filters = QDir::NoFilter,
-        QDir::SortFlags sort = QDir::NoSort) const;
-    /// Returns the list of the entries in the directory.
-    /**
-      \overload
-
-      The same as entryInfoList(QStringList(), filters, sort).
-      */
-    QList<QuaZipFileInfo> entryInfoList(QDir::Filters filters = QDir::NoFilter,
-        QDir::SortFlags sort = QDir::NoSort) const;
-    /// Returns the list of the entry names in the directory.
-    /**
-      The same as entryInfoList(nameFilters, filters, sort), but only
-      returns entry names.
-      */
-    QStringList entryList(const QStringList &nameFilters,
-        QDir::Filters filters = QDir::NoFilter,
-        QDir::SortFlags sort = QDir::NoSort) const;
-    /// Returns the list of the entry names in the directory.
-    /**
-      \overload
-
-      The same as entryList(QStringList(), filters, sort).
-      */
-    QStringList entryList(QDir::Filters filters = QDir::NoFilter,
-        QDir::SortFlags sort = QDir::NoSort) const;
-    /// Returns \c true if the entry with the specified name exists.
-    /**
-      The &quot;..&quot; is considered to exist if the current directory
-      is not root. The &quot;.&quot; and &quot;/&quot; are considered to
-      always exist. Paths starting with &quot;/&quot; are relative to
-      the archive root, other paths are relative to the current dir.
-      */
-    bool exists(const QString &fileName) const;
-    /// Return \c true if the directory pointed by this QuaZipDir exists.
-    bool exists() const;
-    /// Returns the full path to the specified file.
-    /**
-      Doesn't check if the file actually exists.
-      */
-    QString filePath(const QString &fileName) const;
-    /// Returns the default filter.
-    QDir::Filters filter();
-    /// Returns if the QuaZipDir points to the root of the archive.
-    /**
-      Not that the root path is the empty string, not '/'.
-     */
-    bool isRoot() const;
-    /// Return the default name filter.
-    QStringList nameFilters() const;
-    /// Returns the path to the current dir.
-    /**
-      The path never starts with '/', and the root path is an empty
-      string.
-      */
-    QString path() const;
-    /// Returns the path to the specified file relative to the current dir.
-    QString relativeFilePath(const QString &fileName) const;
-    /// Sets the default case sensitivity mode.
-    void setCaseSensitivity(QuaZip::CaseSensitivity caseSensitivity);
-    /// Sets the default filter.
-    void setFilter(QDir::Filters filters);
-    /// Sets the default name filter.
-    void setNameFilters(const QStringList &nameFilters);
-    /// Goes to the specified path.
-    /**
-      The difference from cd() is that this function never checks if the
-      path actually exists and doesn't use relative paths, so it's
-      possible to go to the root directory with setPath(&quot;&quot;).
-
-      Note that this function still chops the trailing and/or leading
-      '/' and treats a single '/' as the root path (path() will still
-      return an empty string).
-      */
-    void setPath(const QString &path);
-    /// Sets the default sorting mode.
-    void setSorting(QDir::SortFlags sort);
-    /// Returns the default sorting mode.
-    QDir::SortFlags sorting() const;
-};
-
-#endif // QUAZIP_QUAZIPDIR_H

interface/external/quazip/include/quazipfile.h

@@ -1,442 +0,0 @@
-#ifndef QUA_ZIPFILE_H
-#define QUA_ZIPFILE_H
-
-/*
-Copyright (C) 2005-2011 Sergey A. Tachenov
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
-your option) any later version.
-
-This program is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
-General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with this program; if not, write to the Free Software Foundation,
-Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-See COPYING file for the full LGPL text.
-
-Original ZIP package is copyrighted by Gilles Vollant, see
-quazip/(un)zip.h files for details, basically it's zlib license.
- **/
-
-#include <QIODevice>
-
-#include "quazip_global.h"
-#include "quazip.h"
-#include "quazipnewinfo.h"
-
-class QuaZipFilePrivate;
-
-/// A file inside ZIP archive.
-/** \class QuaZipFile quazipfile.h <quazip/quazipfile.h>
- * This is the most interesting class. Not only it provides C++
- * interface to the ZIP/UNZIP package, but also integrates it with Qt by
- * subclassing QIODevice. This makes possible to access files inside ZIP
- * archive using QTextStream or QDataStream, for example. Actually, this
- * is the main purpose of the whole QuaZIP library.
- *
- * You can either use existing QuaZip instance to create instance of
- * this class or pass ZIP archive file name to this class, in which case
- * it will create internal QuaZip object. See constructors' descriptions
- * for details. Writing is only possible with the existing instance.
- *
- * Note that due to the underlying library's limitation it is not
- * possible to use multiple QuaZipFile instances to open several files
- * in the same archive at the same time. If you need to write to
- * multiple files in parallel, then you should write to temporary files
- * first, then pack them all at once when you have finished writing. If
- * you need to read multiple files inside the same archive in parallel,
- * you should extract them all into a temporary directory first.
- *
- * \section quazipfile-sequential Sequential or random-access?
- *
- * At the first thought, QuaZipFile has fixed size, the start and the
- * end and should be therefore considered random-access device. But
- * there is one major obstacle to making it random-access: ZIP/UNZIP API
- * does not support seek() operation and the only way to implement it is
- * through reopening the file and re-reading to the required position,
- * but this is prohibitively slow.
- *
- * Therefore, QuaZipFile is considered to be a sequential device. This
- * has advantage of availability of the ungetChar() operation (QIODevice
- * does not implement it properly for non-sequential devices unless they
- * support seek()). Disadvantage is a somewhat strange behaviour of the
- * size() and pos() functions. This should be kept in mind while using
- * this class.
- *
- **/
-class QUAZIP_EXPORT QuaZipFile: public QIODevice {
-  friend class QuaZipFilePrivate;
-  Q_OBJECT
-  private:
-    QuaZipFilePrivate *p;
-    // these are not supported nor implemented
-    QuaZipFile(const QuaZipFile& that);
-    QuaZipFile& operator=(const QuaZipFile& that);
-  protected:
-    /// Implementation of the QIODevice::readData().
-    qint64 readData(char *data, qint64 maxSize);
-    /// Implementation of the QIODevice::writeData().
-    qint64 writeData(const char *data, qint64 maxSize);
-  public:
-    /// Constructs a QuaZipFile instance.
-    /** You should use setZipName() and setFileName() or setZip() before
-     * trying to call open() on the constructed object.
-     **/
-    QuaZipFile();
-    /// Constructs a QuaZipFile instance.
-    /** \a parent argument specifies this object's parent object.
-     *
-     * You should use setZipName() and setFileName() or setZip() before
-     * trying to call open() on the constructed object.
-     **/
-    QuaZipFile(QObject *parent);
-    /// Constructs a QuaZipFile instance.
-    /** \a parent argument specifies this object's parent object and \a
-     * zipName specifies ZIP archive file name.
-     *
-     * You should use setFileName() before trying to call open() on the
-     * constructed object.
-     *
-     * QuaZipFile constructed by this constructor can be used for read
-     * only access. Use QuaZipFile(QuaZip*,QObject*) for writing.
-     **/
-    QuaZipFile(const QString& zipName, QObject *parent =NULL);
-    /// Constructs a QuaZipFile instance.
-    /** \a parent argument specifies this object's parent object, \a
-     * zipName specifies ZIP archive file name and \a fileName and \a cs
-     * specify a name of the file to open inside archive.
-     *
-     * QuaZipFile constructed by this constructor can be used for read
-     * only access. Use QuaZipFile(QuaZip*,QObject*) for writing.
-     *
-     * \sa QuaZip::setCurrentFile()
-     **/
-    QuaZipFile(const QString& zipName, const QString& fileName,
-        QuaZip::CaseSensitivity cs =QuaZip::csDefault, QObject *parent =NULL);
-    /// Constructs a QuaZipFile instance.
-    /** \a parent argument specifies this object's parent object.
-     *
-     * \a zip is the pointer to the existing QuaZip object. This
-     * QuaZipFile object then can be used to read current file in the
-     * \a zip or to write to the file inside it.
-     *
-     * \warning Using this constructor for reading current file can be
-     * tricky. Let's take the following example:
-     * \code
-     * QuaZip zip("archive.zip");
-     * zip.open(QuaZip::mdUnzip);
-     * zip.setCurrentFile("file-in-archive");
-     * QuaZipFile file(&zip);
-     * file.open(QIODevice::ReadOnly);
-     * // ok, now we can read from the file
-     * file.read(somewhere, some);
-     * zip.setCurrentFile("another-file-in-archive"); // oops...
-     * QuaZipFile anotherFile(&zip);
-     * anotherFile.open(QIODevice::ReadOnly);
-     * anotherFile.read(somewhere, some); // this is still ok...
-     * file.read(somewhere, some); // and this is NOT
-     * \endcode
-     * So, what exactly happens here? When we change current file in the
-     * \c zip archive, \c file that references it becomes invalid
-     * (actually, as far as I understand ZIP/UNZIP sources, it becomes
-     * closed, but QuaZipFile has no means to detect it).
-     *
-     * Summary: do not close \c zip object or change its current file as
-     * long as QuaZipFile is open. Even better - use another constructors
-     * which create internal QuaZip instances, one per object, and
-     * therefore do not cause unnecessary trouble. This constructor may
-     * be useful, though, if you already have a QuaZip instance and do
-     * not want to access several files at once. Good example:
-     * \code
-     * QuaZip zip("archive.zip");
-     * zip.open(QuaZip::mdUnzip);
-     * // first, we need some information about archive itself
-     * QByteArray comment=zip.getComment();
-     * // and now we are going to access files inside it
-     * QuaZipFile file(&zip);
-     * for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) {
-     *   file.open(QIODevice::ReadOnly);
-     *   // do something cool with file here
-     *   file.close(); // do not forget to close!
-     * }
-     * zip.close();
-     * \endcode
-     **/
-    QuaZipFile(QuaZip *zip, QObject *parent =NULL);
-    /// Destroys a QuaZipFile instance.
-    /** Closes file if open, destructs internal QuaZip object (if it
-     * exists and \em is internal, of course).
-     **/
-    virtual ~QuaZipFile();
-    /// Returns the ZIP archive file name.
-    /** If this object was created by passing QuaZip pointer to the
-     * constructor, this function will return that QuaZip's file name
-     * (or null string if that object does not have file name yet).
-     *
-     * Otherwise, returns associated ZIP archive file name or null
-     * string if there are no name set yet.
-     *
-     * \sa setZipName() getFileName()
-     **/
-    QString getZipName()const;
-    /// Returns a pointer to the associated QuaZip object.
-    /** Returns \c NULL if there is no associated QuaZip or it is
-     * internal (so you will not mess with it).
-     **/
-    QuaZip* getZip()const;
-    /// Returns file name.
-    /** This function returns file name you passed to this object either
-     * by using
-     * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*)
-     * or by calling setFileName(). Real name of the file may differ in
-     * case if you used case-insensitivity.
-     *
-     * Returns null string if there is no file name set yet. This is the
-     * case when this QuaZipFile operates on the existing QuaZip object
-     * (constructor QuaZipFile(QuaZip*,QObject*) or setZip() was used).
-     * 
-     * \sa getActualFileName
-     **/
-    QString getFileName() const;
-    /// Returns case sensitivity of the file name.
-    /** This function returns case sensitivity argument you passed to
-     * this object either by using
-     * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*)
-     * or by calling setFileName().
-     *
-     * Returns unpredictable value if getFileName() returns null string
-     * (this is the case when you did not used setFileName() or
-     * constructor above).
-     *
-     * \sa getFileName
-     **/
-    QuaZip::CaseSensitivity getCaseSensitivity() const;
-    /// Returns the actual file name in the archive.
-    /** This is \em not a ZIP archive file name, but a name of file inside
-     * archive. It is not necessary the same name that you have passed
-     * to the
-     * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*),
-     * setFileName() or QuaZip::setCurrentFile() - this is the real file
-     * name inside archive, so it may differ in case if the file name
-     * search was case-insensitive.
-     *
-     * Equivalent to calling getCurrentFileName() on the associated
-     * QuaZip object. Returns null string if there is no associated
-     * QuaZip object or if it does not have a current file yet. And this
-     * is the case if you called setFileName() but did not open the
-     * file yet. So this is perfectly fine:
-     * \code
-     * QuaZipFile file("somezip.zip");
-     * file.setFileName("somefile");
-     * QString name=file.getName(); // name=="somefile"
-     * QString actual=file.getActualFileName(); // actual is null string
-     * file.open(QIODevice::ReadOnly);
-     * QString actual=file.getActualFileName(); // actual can be "SoMeFiLe" on Windows
-     * \endcode
-     *
-     * \sa getZipName(), getFileName(), QuaZip::CaseSensitivity
-     **/
-    QString getActualFileName()const;
-    /// Sets the ZIP archive file name.
-    /** Automatically creates internal QuaZip object and destroys
-     * previously created internal QuaZip object, if any.
-     *
-     * Will do nothing if this file is already open. You must close() it
-     * first.
-     **/
-    void setZipName(const QString& zipName);
-    /// Returns \c true if the file was opened in raw mode.
-    /** If the file is not open, the returned value is undefined.
-     *
-     * \sa open(OpenMode,int*,int*,bool,const char*)
-     **/
-    bool isRaw() const;
-    /// Binds to the existing QuaZip instance.
-    /** This function destroys internal QuaZip object, if any, and makes
-     * this QuaZipFile to use current file in the \a zip object for any
-     * further operations. See QuaZipFile(QuaZip*,QObject*) for the
-     * possible pitfalls.
-     *
-     * Will do nothing if the file is currently open. You must close()
-     * it first.
-     **/
-    void setZip(QuaZip *zip);
-    /// Sets the file name.
-    /** Will do nothing if at least one of the following conditions is
-     * met:
-     * - ZIP name has not been set yet (getZipName() returns null
-     *   string).
-     * - This QuaZipFile is associated with external QuaZip. In this
-     *   case you should call that QuaZip's setCurrentFile() function
-     *   instead!
-     * - File is already open so setting the name is meaningless.
-     *
-     * \sa QuaZip::setCurrentFile
-     **/
-    void setFileName(const QString& fileName, QuaZip::CaseSensitivity cs =QuaZip::csDefault);
-    /// Opens a file for reading.
-    /** Returns \c true on success, \c false otherwise.
-     * Call getZipError() to get error code.
-     *
-     * \note Since ZIP/UNZIP API provides buffered reading only,
-     * QuaZipFile does not support unbuffered reading. So do not pass
-     * QIODevice::Unbuffered flag in \a mode, or open will fail.
-     **/
-    virtual bool open(OpenMode mode);
-    /// Opens a file for reading.
-    /** \overload
-     * Argument \a password specifies a password to decrypt the file. If
-     * it is NULL then this function behaves just like open(OpenMode).
-     **/
-    inline bool open(OpenMode mode, const char *password)
-    {return open(mode, NULL, NULL, false, password);}
-    /// Opens a file for reading.
-    /** \overload
-     * Argument \a password specifies a password to decrypt the file.
-     *
-     * An integers pointed by \a method and \a level will receive codes
-     * of the compression method and level used. See unzip.h.
-     *
-     * If raw is \c true then no decompression is performed.
-     *
-     * \a method should not be \c NULL. \a level can be \c NULL if you
-     * don't want to know the compression level.
-     **/
-    bool open(OpenMode mode, int *method, int *level, bool raw, const char *password =NULL);
-    /// Opens a file for writing.
-    /** \a info argument specifies information about file. It should at
-     * least specify a correct file name. Also, it is a good idea to
-     * specify correct timestamp (by default, current time will be
-     * used). See QuaZipNewInfo.
-     *
-     * The \a password argument specifies the password for crypting. Pass NULL
-     * if you don't need any crypting. The \a crc argument was supposed
-     * to be used for crypting too, but then it turned out that it's
-     * false information, so you need to set it to 0 unless you want to
-     * use the raw mode (see below).
-     *
-     * Arguments \a method and \a level specify compression method and
-     * level. The only method supported is Z_DEFLATED, but you may also
-     * specify 0 for no compression. If all of the files in the archive
-     * use both method 0 and either level 0 is explicitly specified or
-     * data descriptor writing is disabled with
-     * QuaZip::setDataDescriptorWritingEnabled(), then the
-     * resulting archive is supposed to be compatible with the 1.0 ZIP
-     * format version, should you need that. Except for this, \a level
-     * has no other effects with method 0.
-     *
-     * If \a raw is \c true, no compression is performed. In this case,
-     * \a crc and uncompressedSize field of the \a info are required.
-     *
-     * Arguments \a windowBits, \a memLevel, \a strategy provide zlib
-     * algorithms tuning. See deflateInit2() in zlib.
-     **/
-    bool open(OpenMode mode, const QuaZipNewInfo& info,
-        const char *password =NULL, quint32 crc =0,
-        int method =Z_DEFLATED, int level =Z_DEFAULT_COMPRESSION, bool raw =false,
-        int windowBits =-MAX_WBITS, int memLevel =DEF_MEM_LEVEL, int strategy =Z_DEFAULT_STRATEGY);
-    /// Returns \c true, but \ref quazipfile-sequential "beware"!
-    virtual bool isSequential()const;
-    /// Returns current position in the file.
-    /** Implementation of the QIODevice::pos(). When reading, this
-     * function is a wrapper to the ZIP/UNZIP unztell(), therefore it is
-     * unable to keep track of the ungetChar() calls (which is
-     * non-virtual and therefore is dangerous to reimplement). So if you
-     * are using ungetChar() feature of the QIODevice, this function
-     * reports incorrect value until you get back characters which you
-     * ungot.
-     *
-     * When writing, pos() returns number of bytes already written
-     * (uncompressed unless you use raw mode).
-     *
-     * \note Although
-     * \ref quazipfile-sequential "QuaZipFile is a sequential device"
-     * and therefore pos() should always return zero, it does not,
-     * because it would be misguiding. Keep this in mind.
-     *
-     * This function returns -1 if the file or archive is not open.
-     *
-     * Error code returned by getZipError() is not affected by this
-     * function call.
-     **/
-    virtual qint64 pos()const;
-    /// Returns \c true if the end of file was reached.
-    /** This function returns \c false in the case of error. This means
-     * that you called this function on either not open file, or a file
-     * in the not open archive or even on a QuaZipFile instance that
-     * does not even have QuaZip instance associated. Do not do that
-     * because there is no means to determine whether \c false is
-     * returned because of error or because end of file was reached.
-     * Well, on the other side you may interpret \c false return value
-     * as "there is no file open to check for end of file and there is
-     * no end of file therefore".
-     *
-     * When writing, this function always returns \c true (because you
-     * are always writing to the end of file).
-     *
-     * Error code returned by getZipError() is not affected by this
-     * function call.
-     **/
-    virtual bool atEnd()const;
-    /// Returns file size.
-    /** This function returns csize() if the file is open for reading in
-     * raw mode, usize() if it is open for reading in normal mode and
-     * pos() if it is open for writing.
-     *
-     * Returns -1 on error, call getZipError() to get error code.
-     *
-     * \note This function returns file size despite that
-     * \ref quazipfile-sequential "QuaZipFile is considered to be sequential device",
-     * for which size() should return bytesAvailable() instead. But its
-     * name would be very misguiding otherwise, so just keep in mind
-     * this inconsistence.
-     **/
-    virtual qint64 size()const;
-    /// Returns compressed file size.
-    /** Equivalent to calling getFileInfo() and then getting
-     * compressedSize field, but more convenient and faster.
-     *
-     * File must be open for reading before calling this function.
-     *
-     * Returns -1 on error, call getZipError() to get error code.
-     **/
-    qint64 csize()const;
-    /// Returns uncompressed file size.
-    /** Equivalent to calling getFileInfo() and then getting
-     * uncompressedSize field, but more convenient and faster. See
-     * getFileInfo() for a warning.
-     *
-     * File must be open for reading before calling this function.
-     *
-     * Returns -1 on error, call getZipError() to get error code.
-     **/
-    qint64 usize()const;
-    /// Gets information about current file.
-    /** This function does the same thing as calling
-     * QuaZip::getCurrentFileInfo() on the associated QuaZip object,
-     * but you can not call getCurrentFileInfo() if the associated
-     * QuaZip is internal (because you do not have access to it), while
-     * you still can call this function in that case.
-     *
-     * File must be open for reading before calling this function.
-     *
-     * Returns \c false in the case of an error.
-     **/
-    bool getFileInfo(QuaZipFileInfo *info);
-    /// Closes the file.
-    /** Call getZipError() to determine if the close was successful.
-     **/
-    virtual void close();
-    /// Returns the error code returned by the last ZIP/UNZIP API call.
-    int getZipError() const;
-    /// Returns the number of bytes available for reading.
-    virtual qint64 bytesAvailable() const;
-};
-
-#endif

interface/external/quazip/include/quazipfileinfo.h

@@ -1,73 +0,0 @@
-#ifndef QUA_ZIPFILEINFO_H
-#define QUA_ZIPFILEINFO_H
-
-/*
-Copyright (C) 2005-2011 Sergey A. Tachenov
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
-your option) any later version.
-
-This program is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
-General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with this program; if not, write to the Free Software Foundation,
-Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-See COPYING file for the full LGPL text.
-
-Original ZIP package is copyrighted by Gilles Vollant, see
-quazip/(un)zip.h files for details, basically it's zlib license.
- **/
-
-#include <QByteArray>
-#include <QDateTime>
-#include <QFile>
-
-#include "quazip_global.h"
-
-/// Information about a file inside archive.
-/** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to
- * fill this structure. */
-struct QUAZIP_EXPORT QuaZipFileInfo {
-  /// File name.
-  QString name;
-  /// Version created by.
-  quint16 versionCreated;
-  /// Version needed to extract.
-  quint16 versionNeeded;
-  /// General purpose flags.
-  quint16 flags;
-  /// Compression method.
-  quint16 method;
-  /// Last modification date and time.
-  QDateTime dateTime;
-  /// CRC.
-  quint32 crc;
-  /// Compressed file size.
-  quint32 compressedSize;
-  /// Uncompressed file size.
-  quint32 uncompressedSize;
-  /// Disk number start.
-  quint16 diskNumberStart;
-  /// Internal file attributes.
-  quint16 internalAttr;
-  /// External file attributes.
-  quint32 externalAttr;
-  /// Comment.
-  QString comment;
-  /// Extra field.
-  QByteArray extra;
-  /// Get the file permissions.
-  /**
-    Returns the high 16 bits of external attributes converted to
-    QFile::Permissions.
-    */
-  QFile::Permissions getPermissions() const;
-};
-
-#endif

interface/external/quazip/include/quazipnewinfo.h

@@ -1,121 +0,0 @@
-#ifndef QUA_ZIPNEWINFO_H
-#define QUA_ZIPNEWINFO_H
-
-/*
-Copyright (C) 2005-2011 Sergey A. Tachenov
-
-This program is free software; you can redistribute it and/or modify it
-under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
-your option) any later version.
-
-This program is distributed in the hope that it will be useful, but
-WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
-General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with this program; if not, write to the Free Software Foundation,
-Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-See COPYING file for the full LGPL text.
-
-Original ZIP package is copyrighted by Gilles Vollant, see
-quazip/(un)zip.h files for details, basically it's zlib license.
- **/
-
-#include <QDateTime>
-#include <QString>
-
-#include "quazip_global.h"
-
-/// Information about a file to be created.
-/** This structure holds information about a file to be created inside
- * ZIP archive. At least name should be set to something correct before
- * passing this structure to
- * QuaZipFile::open(OpenMode,const QuaZipNewInfo&,int,int,bool).
- **/
-struct QUAZIP_EXPORT QuaZipNewInfo {
-  /// File name.
-  /** This field holds file name inside archive, including path relative
-   * to archive root.
-   **/
-  QString name;
-  /// File timestamp.
-  /** This is the last file modification date and time. Will be stored
-   * in the archive central directory. It is a good practice to set it
-   * to the source file timestamp instead of archive creating time. Use
-   * setFileDateTime() or QuaZipNewInfo(const QString&, const QString&).
-   **/
-  QDateTime dateTime;
-  /// File internal attributes.
-  quint16 internalAttr;
-  /// File external attributes.
-  /**
-    The highest 16 bits contain Unix file permissions and type (dir or
-    file). The constructor QuaZipNewInfo(const QString&, const QString&)
-    takes permissions from the provided file.
-    */
-  quint32 externalAttr;
-  /// File comment.
-  /** Will be encoded using QuaZip::getCommentCodec().
-   **/
-  QString comment;
-  /// File local extra field.
-  QByteArray extraLocal;
-  /// File global extra field.
-  QByteArray extraGlobal;
-  /// Uncompressed file size.
-  /** This is only needed if you are using raw file zipping mode, i. e.
-   * adding precompressed file in the zip archive.
-   **/
-  ulong uncompressedSize;
-  /// Constructs QuaZipNewInfo instance.
-  /** Initializes name with \a name, dateTime with current date and
-   * time. Attributes are initialized with zeros, comment and extra
-   * field with null values.
-   **/
-  QuaZipNewInfo(const QString& name);
-  /// Constructs QuaZipNewInfo instance.
-  /** Initializes name with \a name. Timestamp and permissions are taken
-   * from the specified file. If the \a file does not exists or its timestamp
-   * is inaccessible (e. g. you do not have read permission for the
-   * directory file in), uses current time and zero permissions. Other attributes are
-   * initialized with zeros, comment and extra field with null values.
-   * 
-   * \sa setFileDateTime()
-   **/
-  QuaZipNewInfo(const QString& name, const QString& file);
-  /// Sets the file timestamp from the existing file.
-  /** Use this function to set the file timestamp from the existing
-   * file. Use it like this:
-   * \code
-   * QuaZipFile zipFile(&zip);
-   * QFile file("file-to-add");
-   * file.open(QIODevice::ReadOnly);
-   * QuaZipNewInfo info("file-name-in-archive");
-   * info.setFileDateTime("file-to-add"); // take the timestamp from file
-   * zipFile.open(QIODevice::WriteOnly, info);
-   * \endcode
-   *
-   * This function does not change dateTime if some error occured (e. g.
-   * file is inaccessible).
-   **/
-  void setFileDateTime(const QString& file);
-  /// Sets the file permissions from the existing file.
-  /**
-    Takes permissions from the file and sets the high 16 bits of
-    external attributes. Uses QFileInfo to get permissions on all
-    platforms.
-    */
-  void setFilePermissions(const QString &file);
-  /// Sets the file permissions.
-  /**
-    Modifies the highest 16 bits of external attributes. The type part
-    is set to dir if the name ends with a slash, and to regular file
-    otherwise.
-    */
-  void setPermissions(QFile::Permissions permissions);
-};
-
-#endif

interface/external/quazip/include/unzip.h

@@ -1,356 +0,0 @@
-/* unzip.h -- IO for uncompress .zip files using zlib
-   Version 1.01e, February 12th, 2005
-
-   Copyright (C) 1998-2005 Gilles Vollant
-
-   This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
-     WinZip, InfoZip tools and compatible.
-
-   Multi volume ZipFile (span) are not supported.
-   Encryption compatible with pkzip 2.04g only supported
-   Old compressions used by old PKZip 1.x are not supported
-
-
-   I WAIT FEEDBACK at mail info@winimage.com
-   Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
-
-   Condition of use and distribution are the same than zlib :
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-   Modified by Sergey A. Tachenov to integrate with Qt.
-
-
-*/
-
-/* for more info about .ZIP format, see
-      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
-      http://www.info-zip.org/pub/infozip/doc/
-   PkWare has also a specification at :
-      ftp://ftp.pkware.com/probdesc.zip
-*/
-
-#ifndef _unz_H
-#define _unz_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef _ZLIB_H
-#include "zlib.h"
-#endif
-
-#ifndef _ZLIBIOAPI_H
-#include "ioapi.h"
-#endif
-
-#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
-/* like the STRICT of WIN32, we define a pointer that cannot be converted
-    from (void*) without cast */
-typedef struct TagunzFile__ { int unused; } unzFile__;
-typedef unzFile__ *unzFile;
-#else
-typedef voidp unzFile;
-#endif
-
-
-#define UNZ_OK                          (0)
-#define UNZ_END_OF_LIST_OF_FILE         (-100)
-#define UNZ_ERRNO                       (Z_ERRNO)
-#define UNZ_EOF                         (0)
-#define UNZ_PARAMERROR                  (-102)
-#define UNZ_BADZIPFILE                  (-103)
-#define UNZ_INTERNALERROR               (-104)
-#define UNZ_CRCERROR                    (-105)
-
-/* tm_unz contain date/time info */
-typedef struct tm_unz_s
-{
-    uInt tm_sec;            /* seconds after the minute - [0,59] */
-    uInt tm_min;            /* minutes after the hour - [0,59] */
-    uInt tm_hour;           /* hours since midnight - [0,23] */
-    uInt tm_mday;           /* day of the month - [1,31] */
-    uInt tm_mon;            /* months since January - [0,11] */
-    uInt tm_year;           /* years - [1980..2044] */
-} tm_unz;
-
-/* unz_global_info structure contain global data about the ZIPfile
-   These data comes from the end of central dir */
-typedef struct unz_global_info_s
-{
-    uLong number_entry;         /* total number of entries in
-                       the central dir on this disk */
-    uLong size_comment;         /* size of the global comment of the zipfile */
-} unz_global_info;
-
-
-/* unz_file_info contain information about a file in the zipfile */
-typedef struct unz_file_info_s
-{
-    uLong version;              /* version made by                 2 bytes */
-    uLong version_needed;       /* version needed to extract       2 bytes */
-    uLong flag;                 /* general purpose bit flag        2 bytes */
-    uLong compression_method;   /* compression method              2 bytes */
-    uLong dosDate;              /* last mod file date in Dos fmt   4 bytes */
-    uLong crc;                  /* crc-32                          4 bytes */
-    uLong compressed_size;      /* compressed size                 4 bytes */
-    uLong uncompressed_size;    /* uncompressed size               4 bytes */
-    uLong size_filename;        /* filename length                 2 bytes */
-    uLong size_file_extra;      /* extra field length              2 bytes */
-    uLong size_file_comment;    /* file comment length             2 bytes */
-
-    uLong disk_num_start;       /* disk number start               2 bytes */
-    uLong internal_fa;          /* internal file attributes        2 bytes */
-    uLong external_fa;          /* external file attributes        4 bytes */
-
-    tm_unz tmu_date;
-} unz_file_info;
-
-extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
-                                                 const char* fileName2,
-                                                 int iCaseSensitivity));
-/*
-   Compare two filename (fileName1,fileName2).
-   If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
-   If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
-                                or strcasecmp)
-   If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
-    (like 1 on Unix, 2 on Windows)
-*/
-
-
-extern unzFile ZEXPORT unzOpen OF((voidpf file));
-/*
-  Open a Zip file. path contain whatever zopen_file from the IO API
-  accepts. For Qt implementation it is a pointer to QIODevice, for
-  fopen() implementation it's a file name.
-     If the zipfile cannot be opened (file don't exist or in not valid), the
-       return value is NULL.
-     Else, the return value is a unzFile Handle, usable with other function
-       of this unzip package.
-*/
-
-extern unzFile ZEXPORT unzOpen2 OF((voidpf file,
-                                    zlib_filefunc_def* pzlib_filefunc_def));
-/*
-   Open a Zip file, like unzOpen, but provide a set of file low level API
-      for read/write the zip file (see ioapi.h)
-*/
-
-extern int ZEXPORT unzClose OF((unzFile file));
-/*
-  Close a ZipFile opened with unzipOpen.
-  If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
-    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
-  return UNZ_OK if there is no problem. */
-
-extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
-                                        unz_global_info *pglobal_info));
-/*
-  Write info about the ZipFile in the *pglobal_info structure.
-  No preparation of the structure is needed
-  return UNZ_OK if there is no problem. */
-
-
-extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
-                                           char *szComment,
-                                           uLong uSizeBuf));
-/*
-  Get the global comment string of the ZipFile, in the szComment buffer.
-  uSizeBuf is the size of the szComment buffer.
-  return the number of byte copied or an error code <0
-*/
-
-
-/***************************************************************************/
-/* Unzip package allow you browse the directory of the zipfile */
-
-extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
-/*
-  Set the current file of the zipfile to the first file.
-  return UNZ_OK if there is no problem
-*/
-
-extern int ZEXPORT unzGoToNextFile OF((unzFile file));
-/*
-  Set the current file of the zipfile to the next file.
-  return UNZ_OK if there is no problem
-  return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
-*/
-
-extern int ZEXPORT unzLocateFile OF((unzFile file,
-                     const char *szFileName,
-                     int iCaseSensitivity));
-/*
-  Try locate the file szFileName in the zipfile.
-  For the iCaseSensitivity signification, see unzStringFileNameCompare
-
-  return value :
-  UNZ_OK if the file is found. It becomes the current file.
-  UNZ_END_OF_LIST_OF_FILE if the file is not found
-*/
-
-
-/* ****************************************** */
-/* Ryan supplied functions */
-/* unz_file_info contain information about a file in the zipfile */
-typedef struct unz_file_pos_s
-{
-    uLong pos_in_zip_directory;   /* offset in zip file directory */
-    uLong num_of_file;            /* # of file */
-} unz_file_pos;
-
-extern int ZEXPORT unzGetFilePos(
-    unzFile file,
-    unz_file_pos* file_pos);
-
-extern int ZEXPORT unzGoToFilePos(
-    unzFile file,
-    unz_file_pos* file_pos);
-
-/* ****************************************** */
-
-extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
-                         unz_file_info *pfile_info,
-                         char *szFileName,
-                         uLong fileNameBufferSize,
-                         void *extraField,
-                         uLong extraFieldBufferSize,
-                         char *szComment,
-                         uLong commentBufferSize));
-/*
-  Get Info about the current file
-  if pfile_info!=NULL, the *pfile_info structure will contain somes info about
-        the current file
-  if szFileName!=NULL, the filemane string will be copied in szFileName
-            (fileNameBufferSize is the size of the buffer)
-  if extraField!=NULL, the extra field information will be copied in extraField
-            (extraFieldBufferSize is the size of the buffer).
-            This is the Central-header version of the extra field
-  if szComment!=NULL, the comment string of the file will be copied in szComment
-            (commentBufferSize is the size of the buffer)
-*/
-
-/***************************************************************************/
-/* for reading the content of the current zipfile, you can open it, read data
-   from it, and close it (you can close it before reading all the file)
-   */
-
-extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
-/*
-  Open for reading data the current file in the zipfile.
-  If there is no error, the return value is UNZ_OK.
-*/
-
-extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
-                                                  const char* password));
-/*
-  Open for reading data the current file in the zipfile.
-  password is a crypting password
-  If there is no error, the return value is UNZ_OK.
-*/
-
-extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
-                                           int* method,
-                                           int* level,
-                                           int raw));
-/*
-  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-    if raw==1
-  *method will receive method of compression, *level will receive level of
-     compression
-  note : you can set level parameter as NULL (if you did not want known level,
-         but you CANNOT set method parameter as NULL
-*/
-
-extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
-                                           int* method,
-                                           int* level,
-                                           int raw,
-                                           const char* password));
-/*
-  Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
-    if raw==1
-  *method will receive method of compression, *level will receive level of
-     compression
-  note : you can set level parameter as NULL (if you did not want known level,
-         but you CANNOT set method parameter as NULL
-*/
-
-
-extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
-/*
-  Close the file in zip opened with unzOpenCurrentFile
-  Return UNZ_CRCERROR if all the file was read but the CRC is not good
-*/
-
-extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
-                      voidp buf,
-                      unsigned len));
-/*
-  Read bytes from the current file (opened by unzOpenCurrentFile)
-  buf contain buffer where data must be copied
-  len the size of buf.
-
-  return the number of byte copied if somes bytes are copied
-  return 0 if the end of file was reached
-  return <0 with error code if there is an error
-    (UNZ_ERRNO for IO error, or zLib error for uncompress error)
-*/
-
-extern z_off_t ZEXPORT unztell OF((unzFile file));
-/*
-  Give the current position in uncompressed data
-*/
-
-extern int ZEXPORT unzeof OF((unzFile file));
-/*
-  return 1 if the end of file was reached, 0 elsewhere
-*/
-
-extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
-                                             voidp buf,
-                                             unsigned len));
-/*
-  Read extra field from the current file (opened by unzOpenCurrentFile)
-  This is the local-header version of the extra field (sometimes, there is
-    more info in the local-header version than in the central-header)
-
-  if buf==NULL, it return the size of the local extra field
-
-  if buf!=NULL, len is the size of the buffer, the extra header is copied in
-    buf.
-  the return value is the number of bytes copied in buf, or (if <0)
-    the error code
-*/
-
-/***************************************************************************/
-
-/* Get the current file offset */
-extern uLong ZEXPORT unzGetOffset (unzFile file);
-
-/* Set the current file offset */
-extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
-
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _unz_H */

interface/external/quazip/include/zip.h

@@ -1,245 +0,0 @@
-/* zip.h -- IO for compress .zip files using zlib
-   Version 1.01e, February 12th, 2005
-
-   Copyright (C) 1998-2005 Gilles Vollant
-
-   This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
-     WinZip, InfoZip tools and compatible.
-   Multi volume ZipFile (span) are not supported.
-   Encryption compatible with pkzip 2.04g only supported
-   Old compressions used by old PKZip 1.x are not supported
-
-  For uncompress .zip file, look at unzip.h
-
-
-   I WAIT FEEDBACK at mail info@winimage.com
-   Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
-
-   Condition of use and distribution are the same than zlib :
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-   Modified by Sergey A. Tachenov to integrate with Qt.
-
-
-*/
-
-/* for more info about .ZIP format, see
-      http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
-      http://www.info-zip.org/pub/infozip/doc/
-   PkWare has also a specification at :
-      ftp://ftp.pkware.com/probdesc.zip
-*/
-
-#ifndef _zip_H
-#define _zip_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef _ZLIB_H
-#include "zlib.h"
-#endif
-
-#ifndef _ZLIBIOAPI_H
-#include "ioapi.h"
-#endif
-
-#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
-/* like the STRICT of WIN32, we define a pointer that cannot be converted
-    from (void*) without cast */
-typedef struct TagzipFile__ { int unused; } zipFile__;
-typedef zipFile__ *zipFile;
-#else
-typedef voidp zipFile;
-#endif
-
-#define ZIP_OK                          (0)
-#define ZIP_EOF                         (0)
-#define ZIP_ERRNO                       (Z_ERRNO)
-#define ZIP_PARAMERROR                  (-102)
-#define ZIP_BADZIPFILE                  (-103)
-#define ZIP_INTERNALERROR               (-104)
-
-#define ZIP_WRITE_DATA_DESCRIPTOR 0x8u
-
-#ifndef DEF_MEM_LEVEL
-#  if MAX_MEM_LEVEL >= 8
-#    define DEF_MEM_LEVEL 8
-#  else
-#    define DEF_MEM_LEVEL  MAX_MEM_LEVEL
-#  endif
-#endif
-/* default memLevel */
-
-/* tm_zip contain date/time info */
-typedef struct tm_zip_s
-{
-    uInt tm_sec;            /* seconds after the minute - [0,59] */
-    uInt tm_min;            /* minutes after the hour - [0,59] */
-    uInt tm_hour;           /* hours since midnight - [0,23] */
-    uInt tm_mday;           /* day of the month - [1,31] */
-    uInt tm_mon;            /* months since January - [0,11] */
-    uInt tm_year;           /* years - [1980..2044] */
-} tm_zip;
-
-typedef struct
-{
-    tm_zip      tmz_date;       /* date in understandable format           */
-    uLong       dosDate;       /* if dos_date == 0, tmu_date is used      */
-/*    uLong       flag;        */   /* general purpose bit flag        2 bytes */
-
-    uLong       internal_fa;    /* internal file attributes        2 bytes */
-    uLong       external_fa;    /* external file attributes        4 bytes */
-} zip_fileinfo;
-
-typedef const char* zipcharpc;
-
-
-#define APPEND_STATUS_CREATE        (0)
-#define APPEND_STATUS_CREATEAFTER   (1)
-#define APPEND_STATUS_ADDINZIP      (2)
-
-extern zipFile ZEXPORT zipOpen OF((voidpf file, int append));
-/*
-  Create a zipfile.
-     file is whatever the IO API accepts. For Qt IO API it's a pointer to
-       QIODevice. For fopen() IO API it's a file name (const char*).
-     if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
-       will be created at the end of the file.
-         (useful if the file contain a self extractor code)
-     if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
-       add files in existing zip (be sure you don't add file that doesn't exist)
-     If the zipfile cannot be opened, the return value is NULL.
-     Else, the return value is a zipFile Handle, usable with other function
-       of this zip package.
-*/
-
-/* Note : there is no delete function into a zipfile.
-   If you want delete file into a zipfile, you must open a zipfile, and create another
-   Of couse, you can use RAW reading and writing to copy the file you did not want delte
-*/
-
-extern zipFile ZEXPORT zipOpen2 OF((voidpf file,
-                                   int append,
-                                   zipcharpc* globalcomment,
-                                   zlib_filefunc_def* pzlib_filefunc_def));
-
-extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
-                       const char* filename,
-                       const zip_fileinfo* zipfi,
-                       const void* extrafield_local,
-                       uInt size_extrafield_local,
-                       const void* extrafield_global,
-                       uInt size_extrafield_global,
-                       const char* comment,
-                       int method,
-                       int level));
-/*
-  Open a file in the ZIP for writing.
-  filename : the filename in zip (if NULL, '-' without quote will be used
-  *zipfi contain supplemental information
-  if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
-    contains the extrafield data the the local header
-  if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
-    contains the extrafield data the the local header
-  if comment != NULL, comment contain the comment string
-  method contain the compression method (0 for store, Z_DEFLATED for deflate)
-  level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
-*/
-
-
-extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw));
-
-/*
-  Same than zipOpenNewFileInZip, except if raw=1, we write raw file
- */
-
-extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
-                                            const char* filename,
-                                            const zip_fileinfo* zipfi,
-                                            const void* extrafield_local,
-                                            uInt size_extrafield_local,
-                                            const void* extrafield_global,
-                                            uInt size_extrafield_global,
-                                            const char* comment,
-                                            int method,
-                                            int level,
-                                            int raw,
-                                            int windowBits,
-                                            int memLevel,
-                                            int strategy,
-                                            const char* password,
-                                            uLong crcForCtypting));
-
-/*
-  Same than zipOpenNewFileInZip2, except
-    windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
-    password : crypting password (NULL for no crypting)
-    crcForCtypting : crc of file to compress (needed for crypting)
- */
-
-
-extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
-                       const void* buf,
-                       unsigned len));
-/*
-  Write data in the zipfile
-*/
-
-extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
-/*
-  Close the current file in the zipfile
-*/
-
-extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
-                                            uLong uncompressed_size,
-                                            uLong crc32));
-/*
-  Close the current file in the zipfile, for fiel opened with
-    parameter raw=1 in zipOpenNewFileInZip2
-  uncompressed_size and crc32 are value for the uncompressed size
-*/
-
-extern int ZEXPORT zipClose OF((zipFile file,
-                const char* global_comment));
-/*
-  Close the zipfile
-*/
-
-/*
-   Added by Sergey A. Tachenov to tweak zipping behaviour.
-   */
-extern int ZEXPORT zipSetFlags(zipFile file, unsigned flags);
-extern int ZEXPORT zipClearFlags(zipFile file, unsigned flags);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _zip_H */

interface/src/Application.cpp

@@ -320,11 +320,6 @@ void Application::initializeGL() {
     // update before the first render
     update(0.0f);
     
-    // now that things are drawn - if this is an OS X release build we can check for an update
-#if defined(Q_OS_MAC) && defined(QT_NO_DEBUG)
-    Menu::getInstance()->checkForUpdates();
-#endif
-
     InfoView::showFirstTime();
 }
 

interface/src/Menu.cpp

@@ -21,7 +21,6 @@
 #include <QStandardPaths>
 
 #include "Application.h"
-#include "fvupdater.h"
 #include "PairingHandler.h"
 #include "Menu.h"
 #include "Util.h"
@@ -69,16 +68,7 @@ Menu::Menu() :
                                    Qt::CTRL | Qt::Key_Comma,
                                    this,
                                    SLOT(editPreferences())))->setMenuRole(QAction::PreferencesRole);
-    
-#if defined(Q_OS_MAC) && defined(QT_NO_DEBUG)
-    // show "Check for Updates" in the menu
-    (addActionToQMenuAndActionHash(fileMenu,
-                                   MenuOption::CheckForUpdates,
-                                   0,
-                                   this,
-                                   SLOT(checkForUpdates())))->setMenuRole(QAction::ApplicationSpecificRole);
-#endif
-    
+
     addDisabledActionAndSeparator(fileMenu, "Voxels");
     addActionToQMenuAndActionHash(fileMenu, MenuOption::ExportVoxels, Qt::CTRL | Qt::Key_E, appInstance, SLOT(exportVoxels()));
     addActionToQMenuAndActionHash(fileMenu, MenuOption::ImportVoxels, Qt::CTRL | Qt::Key_I, appInstance, SLOT(importVoxels()));
@@ -555,15 +545,6 @@ void Menu::exportSettings() {
     }
 }
 
-void Menu::checkForUpdates() {
-#if defined(Q_OS_MAC) && defined(QT_NO_DEBUG)
-    qDebug() << "Checking if there are available updates.\n";
-    // if this is a release OS X build use fervor to check for an update
-    FvUpdater::sharedUpdater()->SetFeedURL("http://s3.highfidelity.io/appcast.xml");
-    FvUpdater::sharedUpdater()->CheckForUpdatesSilent();
-#endif
-}
-
 void Menu::loadAction(QSettings* set, QAction* action) {
     if (action->isChecked() != set->value(action->text(), action->isChecked()).toBool()) {
         action->trigger();

interface/src/Menu.h

@@ -65,7 +65,6 @@ public slots:
     void saveSettings(QSettings* settings = NULL);
     void importSettings();
     void exportSettings();
-    void checkForUpdates();
     
 private slots:
     void aboutApp();
@@ -128,7 +127,6 @@ namespace MenuOption {
     const QString Atmosphere = "Atmosphere";
     const QString Bandwidth = "Bandwidth Display";
     const QString BandwidthDetails = "Bandwidth Details";
-    const QString CheckForUpdates = "Check for Updates...";
     const QString Collisions = "Collisions";
     const QString CopyVoxels = "Copy";
     const QString CoverageMap = "Render Coverage Map";

libraries/shared/src/Assignment.cpp

@@ -9,37 +9,94 @@
 #include "PacketHeaders.h"
 #include "SharedUtil.h"
 
+#include <QtCore/QDataStream>
+
 #include "Assignment.h"
 
 const char IPv4_ADDRESS_DESIGNATOR = 4;
 const char IPv6_ADDRESS_DESIGNATOR = 6;
 
+Assignment::Type Assignment::typeForNodeType(NODE_TYPE nodeType) {
+    switch (nodeType) {
+        case NODE_TYPE_AUDIO_MIXER:
+            return Assignment::AudioMixerType;
+        case NODE_TYPE_AVATAR_MIXER:
+            return Assignment::AvatarMixerType;
+        case NODE_TYPE_AGENT:
+            return Assignment::AgentType;
+        case NODE_TYPE_VOXEL_SERVER:
+            return Assignment::VoxelServerType;
+        default:
+            return Assignment::AllTypes;
+    }
+}
+
+Assignment::Assignment() :
+    _uuid(),
+    _command(Assignment::RequestCommand),
+    _type(Assignment::AllTypes),
+    _location(Assignment::LocalLocation),
+    _numberOfInstances(1),
+    _payload(),
+    _numPayloadBytes(0)
+{
+    
+}
+
 Assignment::Assignment(Assignment::Command command, Assignment::Type type, Assignment::Location location) :
     _command(command),
     _type(type),
     _location(location),
     _numberOfInstances(1),
-    _payload(NULL),
+    _payload(),
     _numPayloadBytes(0)
 {
-    // set the create time on this assignment
-    gettimeofday(&_time, NULL);
-    
     if (_command == Assignment::CreateCommand) {
         // this is a newly created assignment, generate a random UUID
         _uuid = QUuid::createUuid();
     }
 }
 
+Assignment::Assignment(const Assignment& otherAssignment) {
+    
+    _uuid = otherAssignment._uuid;
+    
+    _command = otherAssignment._command;
+    _type = otherAssignment._type;
+    _location = otherAssignment._location;
+    _numberOfInstances = otherAssignment._numberOfInstances;
+    
+    setPayload(otherAssignment._payload, otherAssignment._numPayloadBytes);
+}
+
+Assignment& Assignment::operator=(const Assignment& rhsAssignment) {
+    Assignment temp(rhsAssignment);
+    swap(temp);
+    return *this;
+}
+
+void Assignment::swap(Assignment& otherAssignment) {
+    using std::swap;
+    
+    swap(_uuid, otherAssignment._uuid);
+    swap(_command, otherAssignment._command);
+    swap(_type, otherAssignment._type);
+    swap(_location, otherAssignment._location);
+    swap(_numberOfInstances, otherAssignment._numberOfInstances);
+    
+    for (int i = 0; i < MAX_PAYLOAD_BYTES; i++) {
+        swap(_payload[i], otherAssignment._payload[i]);
+    }
+    
+    swap(_numPayloadBytes, otherAssignment._numPayloadBytes);
+}
+
 Assignment::Assignment(const unsigned char* dataBuffer, int numBytes) :
     _location(GlobalLocation),
     _numberOfInstances(1),
-    _payload(NULL),
+    _payload(),
     _numPayloadBytes(0)
-{
-    // set the create time on this assignment
-    gettimeofday(&_time, NULL);
-    
+{    
     int numBytesRead = 0;
     
     if (dataBuffer[0] == PACKET_TYPE_REQUEST_ASSIGNMENT) {
@@ -62,19 +119,10 @@ Assignment::Assignment(const unsigned char* dataBuffer, int numBytes) :
     }
 
     if (numBytes > numBytesRead) {
-        _numPayloadBytes = numBytes - numBytesRead;
-        _payload =  new uchar[_numPayloadBytes];
-        memcpy(_payload, dataBuffer + numBytesRead, _numPayloadBytes);
+        setPayload(dataBuffer + numBytesRead, numBytes - numBytesRead);
     }
 }
 
-Assignment::~Assignment() {
-    delete[] _payload;
-    _numPayloadBytes = 0;
-}
-
-const int MAX_PAYLOAD_BYTES = 1024;
-
 void Assignment::setPayload(const uchar* payload, int numBytes) {
     
     if (numBytes > MAX_PAYLOAD_BYTES) {
@@ -87,8 +135,7 @@ void Assignment::setPayload(const uchar* payload, int numBytes) {
         _numPayloadBytes = numBytes;
     }
     
-    delete[] _payload;
-    _payload = new uchar[_numPayloadBytes];
+    memset(_payload, 0, MAX_PAYLOAD_BYTES);
     memcpy(_payload, payload, _numPayloadBytes);
 }
 
@@ -121,6 +168,7 @@ void Assignment::run() {
 }
 
 QDebug operator<<(QDebug debug, const Assignment &assignment) {
-    debug << "T:" << assignment.getType();
+    debug.nospace() << "UUID: " << assignment.getUUID().toString().toStdString().c_str() <<
+        ", Type: " << assignment.getType();
     return debug.nospace();
-}
+}

libraries/shared/src/Assignment.h

@@ -16,9 +16,10 @@
 #include "NodeList.h"
 
 const int NUM_BYTES_RFC4122_UUID = 16;
+const int MAX_PAYLOAD_BYTES = 1024;
 
 /// Holds information used for request, creation, and deployment of assignments
-class Assignment : public QObject {
+class Assignment : public NodeData {
     Q_OBJECT
 public:
     
@@ -41,17 +42,23 @@ public:
         LocalLocation
     };
     
+    static Assignment::Type typeForNodeType(NODE_TYPE nodeType);
+    
+    Assignment();
     Assignment(Assignment::Command command,
                Assignment::Type type,
                Assignment::Location location = Assignment::LocalLocation);
+    Assignment(const Assignment& otherAssignment);
+    Assignment& operator=(const Assignment &rhsAssignment);
+    
+    void swap(Assignment& otherAssignment);
     
     /// Constructs an Assignment from the data in the buffer
     /// \param dataBuffer the source buffer to un-pack the assignment from
     /// \param numBytes the number of bytes left to read in the source buffer
     Assignment(const unsigned char* dataBuffer, int numBytes);
     
-    ~Assignment();
-    
+    void setUUID(const QUuid& uuid) { _uuid = uuid; }
     const QUuid& getUUID() const { return _uuid; }
     QString getUUIDStringWithoutCurlyBraces() const;
     void resetUUID() { _uuid = QUuid::createUuid(); }
@@ -59,7 +66,6 @@ public:
     Assignment::Command getCommand() const { return _command; }
     Assignment::Type getType() const { return _type; }
     Assignment::Location getLocation() const { return _location; }
-    const timeval& getTime() const { return _time; }
     
     uchar* getPayload() { return _payload; }
     int getNumPayloadBytes() const { return _numPayloadBytes; }
@@ -74,23 +80,24 @@ public:
     /// \return number of bytes packed into buffer
     int packToBuffer(unsigned char* buffer);
     
-    /// Sets _time to the current time given by gettimeofday
-    void setCreateTimeToNow() { gettimeofday(&_time, NULL); }
+    // implement parseData to return 0 so we can be a subclass of NodeData
+    int parseData(unsigned char* sourceBuffer, int numBytes) { return 0; }
     
     /// blocking run of the assignment
     virtual void run();
     
-private:
+    friend QDebug operator<<(QDebug debug, const Assignment& assignment);
+    friend QDataStream& operator<<(QDataStream &out, const Assignment& assignment);
+    friend QDataStream& operator>>(QDataStream &in, Assignment& assignment);
+    
+protected:
     QUuid _uuid; /// the 16 byte UUID for this assignment
     Assignment::Command _command; /// the command for this assignment (Create, Deploy, Request)
     Assignment::Type _type; /// the type of the assignment, defines what the assignee will do
     Assignment::Location _location; /// the location of the assignment, allows a domain to preferentially use local ACs
-    timeval _time; /// time the assignment was created (set in constructor)
     int _numberOfInstances; /// the number of instances of this assignment
-    uchar *_payload; /// an optional payload attached to this assignment, a maximum for 1024 bytes will be packed
+    uchar _payload[MAX_PAYLOAD_BYTES]; /// an optional payload attached to this assignment, a maximum for 1024 bytes will be packed
     int _numPayloadBytes; /// number of bytes in the payload, up to a maximum of 1024
 };
 
-QDebug operator<<(QDebug debug, const Assignment &assignment);
-
 #endif /* defined(__hifi__Assignment__) */

libraries/shared/src/NodeData.h

@@ -16,7 +16,7 @@ class Node;
 class NodeData : public QObject {
   Q_OBJECT
 public:
-    NodeData(Node* owningNode);
+    NodeData(Node* owningNode = NULL);
     
     virtual ~NodeData() = 0;
     virtual int parseData(unsigned char* sourceBuffer, int numBytes) = 0;

libraries/shared/src/NodeList.cpp

@@ -291,7 +291,7 @@ void NodeList::sendDomainServerCheckIn(const char* assignmentUUID) {
     
     //  Lookup the IP address of the domain server if we need to
     if (_domainIP.isNull()) {
-        qDebug("Looking up DS hostname %s.\n", _domainHostname.toStdString().c_str());
+        qDebug("Looking up DS hostname %s.\n", _domainHostname.toLocal8Bit().constData());
         
         QHostInfo domainServerHostInfo = QHostInfo::fromName(_domainHostname);
         
@@ -299,7 +299,8 @@ void NodeList::sendDomainServerCheckIn(const char* assignmentUUID) {
             if (domainServerHostInfo.addresses()[i].protocol() == QAbstractSocket::IPv4Protocol) {
                 _domainIP = domainServerHostInfo.addresses()[i];
                 
-                qDebug("DS at %s is at %s\n", _domainHostname.toStdString().c_str(), _domainIP.toString().toStdString().c_str());
+                qDebug("DS at %s is at %s\n", _domainHostname.toLocal8Bit().constData(),
+                       _domainIP.toString().toLocal8Bit().constData());
                 
                 printedDomainServerIP = true;
                 
@@ -312,7 +313,7 @@ void NodeList::sendDomainServerCheckIn(const char* assignmentUUID) {
             }
         }
     } else if (!printedDomainServerIP) {
-        qDebug("Domain Server IP: %s\n", _domainIP.toString().toStdString().c_str());
+        qDebug("Domain Server IP: %s\n", _domainIP.toString().toLocal8Bit().constData());
         printedDomainServerIP = true;
     }
     
@@ -362,7 +363,7 @@ void NodeList::sendDomainServerCheckIn(const char* assignmentUUID) {
         _numBytesCheckInPacket = packetPosition - _checkInPacket;
     }
     
-    _nodeSocket.send(_domainIP.toString().toStdString().c_str(), _domainPort, _checkInPacket, _numBytesCheckInPacket);
+    _nodeSocket.send(_domainIP.toString().toLocal8Bit().constData(), _domainPort, _checkInPacket, _numBytesCheckInPacket);
     
     // increment the count of un-replied check-ins
     _numNoReplyDomainCheckIns++;
@@ -438,12 +439,7 @@ Node* NodeList::addOrUpdateNode(sockaddr* publicSocket, sockaddr* localSocket, c
         }
     }
     
-    if (node == end()) {
-        // if we already had this node AND it's a solo type then bust out of here
-        if (soloNodeOfType(nodeType)) {
-            return NULL;
-        }
-        
+    if (node == end()) {        
         // we didn't have this node, so add them
         Node* newNode = new Node(publicSocket, localSocket, nodeType, nodeId);
         

libraries/voxel-server-library/src/VoxelServer.cpp

@@ -13,8 +13,8 @@
 
 #include <QDebug>
 #include <QString>
-#include <QStringList>
 
+#include <Logging.h>
 #include <OctalCode.h>
 #include <NodeList.h>
 #include <NodeTypes.h>
@@ -115,34 +115,9 @@ void VoxelServer::setArguments(int argc, char** argv) {
 void VoxelServer::parsePayload() {
     
     if (getNumPayloadBytes() > 0) {
-        QString multiConfig((const char*)getPayload());
-        QStringList multiConfigList = multiConfig.split(";");
+        QString config((const char*) _payload);
         
-        // There there are multiple configs, then this instance will run the first
-        // config, and launch Assignment requests for the additional configs.
-        if (multiConfigList.size() > 1) {
-            qDebug("Voxel Server received assignment for multiple Configs... config count=%d\n", multiConfigList.size());
-
-            // skip 0 - that's the one we'll run
-            for (int i = 1; i < multiConfigList.size(); i++) {
-                QString config = multiConfigList.at(i);
-                
-                qDebug("   config[%d]=%s\n", i, config.toLocal8Bit().constData());
-
-                Assignment voxelServerAssignment(Assignment::CreateCommand,
-                                                 Assignment::VoxelServerType,
-                                                 getLocation()); // use same location as we were created in.
-
-                int payloadLength = config.length() + sizeof(char);
-                voxelServerAssignment.setPayload((uchar*)config.toLocal8Bit().constData(), payloadLength);
-                
-                qDebug("Requesting additional Voxel Server assignment to handle config %d\n", i);
-                NodeList::getInstance()->sendAssignment(voxelServerAssignment);
-            }
-        }
-        
-        // Now, parse the first config
-        QString config = multiConfigList.at(0);
+        // Now, parse the config
         QStringList configList = config.split(" ");
         
         int argCount = configList.size() + 1;
@@ -167,6 +142,11 @@ void VoxelServer::parsePayload() {
 
 //int main(int argc, const char * argv[]) {
 void VoxelServer::run() {
+    
+    const char VOXEL_SERVER_LOGGING_TARGET_NAME[] = "voxel-server";
+    
+    // change the logging target name while this is running
+    Logging::setTargetName(VOXEL_SERVER_LOGGING_TARGET_NAME);
 
     // Now would be a good time to parse our arguments, if we got them as assignment
     if (getNumPayloadBytes() > 0) {
@@ -175,7 +155,7 @@ void VoxelServer::run() {
 
     pthread_mutex_init(&_treeLock, NULL);
     
-    qInstallMessageHandler(sharedMessageHandler);
+    qInstallMessageHandler(Logging::verboseMessageHandler);
     
     const char* JURISDICTION_FILE = "--jurisdictionFile";
     const char* jurisdictionFile = getCmdOption(_argc, _argv, JURISDICTION_FILE);
@@ -358,7 +338,7 @@ void VoxelServer::run() {
         // send a check in packet to the domain server if DOMAIN_SERVER_CHECK_IN_USECS has elapsed
         if (usecTimestampNow() - usecTimestamp(&lastDomainServerCheckIn) >= DOMAIN_SERVER_CHECK_IN_USECS) {
             gettimeofday(&lastDomainServerCheckIn, NULL);
-            NodeList::getInstance()->sendDomainServerCheckIn();
+            NodeList::getInstance()->sendDomainServerCheckIn(_uuid.toRfc4122().constData());
         }
         
         if (nodeList->getNodeSocket()->receive(&senderAddress, packetData, &packetLength) &&

libraries/voxel-server-library/src/VoxelServer.h

@@ -10,6 +10,8 @@
 #ifndef __voxel_server__VoxelServer__
 #define __voxel_server__VoxelServer__
 
+#include <QStringList>
+
 #include <Assignment.h>
 #include <EnvironmentData.h>