fail asset request if hash does not match

interface/src/ui/AssetUploadDialogFactory.cpp

@@ -69,7 +69,7 @@ void AssetUploadDialogFactory::showDialog() {
 }
 
 void AssetUploadDialogFactory::handleUploadFinished(AssetUpload* upload, const QString& hash) {
-    if (upload->getResult() == AssetUpload::Success) {
+    if (upload->getError() == AssetUpload::NoError) {
         // show message box for successful upload, with copiable text for ATP hash
         QDialog* hashCopyDialog = new QDialog(_dialogParent);
         
@@ -124,14 +124,14 @@ void AssetUploadDialogFactory::handleUploadFinished(AssetUpload* upload, const Q
         // figure out the right error message for the message box
         QString additionalError;
         
-        switch (upload->getResult()) {
+        switch (upload->getError()) {
             case AssetUpload::PermissionDenied:
                 additionalError = PERMISSION_DENIED_ERROR;
                 break;
             case AssetUpload::TooLarge:
                 additionalError = "The uploaded content was too large and could not be stored in the asset-server.";
                 break;
-            case AssetUpload::ErrorLoadingFile:
+            case AssetUpload::FileOpenError:
                 additionalError = "The file could not be opened. Please check your permissions and try again.";
                 break;
             default:

libraries/networking/src/AssetClient.h

@@ -29,9 +29,9 @@ struct AssetInfo {
     int64_t size;
 };
 
-using ReceivedAssetCallback = std::function<void(AssetServerError error, const QByteArray& data)>;
-using GetInfoCallback = std::function<void(AssetServerError error, AssetInfo info)>;
-using UploadResultCallback = std::function<void(AssetServerError error, const QString& hash)>;
+using ReceivedAssetCallback = std::function<void(AssetServerError serverError, const QByteArray& data)>;
+using GetInfoCallback = std::function<void(AssetServerError serverError, AssetInfo info)>;
+using UploadResultCallback = std::function<void(AssetServerError serverError, const QString& hash)>;
 
 class AssetClient : public QObject, public Dependency {
     Q_OBJECT

libraries/networking/src/AssetRequest.cpp

@@ -41,14 +41,17 @@ void AssetRequest::start() {
     _state = WAITING_FOR_INFO;
     
     auto assetClient = DependencyManager::get<AssetClient>();
-    assetClient->getAssetInfo(_hash, _extension, [this](AssetServerError error, AssetInfo info) {
+    assetClient->getAssetInfo(_hash, _extension, [this](AssetServerError serverError, AssetInfo info) {
         _info = info;
-        _error = error;
         
-        if (_error != NoError) {
+        if (serverError != AssetServerError::NoError) {
             qCDebug(networking) << "Got error retrieving asset info for" << _hash;
+            
             _state = FINISHED;
             emit finished(this);
+            
+            _error = (serverError == AssetServerError::AssetNotFound) ? NotFound : UnknownError;
+            
             return;
         }
         
@@ -60,17 +63,38 @@ void AssetRequest::start() {
         int start = 0, end = _info.size;
         
         auto assetClient = DependencyManager::get<AssetClient>();
-        assetClient->getAsset(_hash, _extension, start, end, [this, start, end](AssetServerError error,
+        assetClient->getAsset(_hash, _extension, start, end, [this, start, end](AssetServerError serverError,
                                                                                 const QByteArray& data) {
             Q_ASSERT(data.size() == (end - start));
             
-            _error = error;
-            if (_error == NoError) {
-                memcpy(_data.data() + start, data.constData(), data.size());
-                _totalReceived += data.size();
-                emit progress(_totalReceived, _info.size);
+            if (serverError == AssetServerError::NoError) {
+                
+                // we need to check the hash of the received data to make sure it matches what we expect
+                if (hashData(data).toHex() == _hash) {
+                    memcpy(_data.data() + start, data.constData(), data.size());
+                    _totalReceived += data.size();
+                    emit progress(_totalReceived, _info.size);
+                } else {
+                    // hash doesn't match - we have an error
+                    _error = HashVerificationFailed;
+                }
+                
             } else {
-                qCDebug(networking) << "Got error retrieving asset" << _hash;
+                switch (serverError) {
+                    case AssetServerError::AssetNotFound:
+                        _error = NotFound;
+                        break;
+                    case AssetServerError::InvalidByteRange:
+                        _error = InvalidByteRange;
+                        break;
+                    default:
+                        _error = UnknownError;
+                        break;
+                }
+            }
+            
+            if (_error != NoError) {
+                qCDebug(networking) << "Got error retrieving asset" << _hash << "- error code" << _error;
             }
             
             _state = FINISHED;

libraries/networking/src/AssetRequest.h

@@ -29,14 +29,22 @@ public:
         WAITING_FOR_DATA,
         FINISHED
     };
+    
+    enum Error {
+        NoError,
+        NotFound,
+        InvalidByteRange,
+        HashVerificationFailed,
+        UnknownError
+    };
 
     AssetRequest(QObject* parent, const QString& hash, const QString& extension);
 
     Q_INVOKABLE void start();
 
     const QByteArray& getData() const { return _data; }
-    State getState() const { return _state; }
-    AssetServerError getError() const { return _error; }
+    const State& getState() const { return _state; }
+    const Error& getError() const { return _error; }
 
 signals:
     void finished(AssetRequest* thisRequest);
@@ -44,7 +52,7 @@ signals:
 
 private:
     State _state = NOT_STARTED;
-    AssetServerError _error;
+    Error _error = NoError;
     AssetInfo _info;
     uint64_t _totalReceived { 0 };
     QString _hash;

libraries/networking/src/AssetResourceRequest.cpp

@@ -48,11 +48,11 @@ void AssetResourceRequest::doSend() {
         Q_ASSERT(req->getState() == AssetRequest::FINISHED);
         
         switch (req->getError()) {
-            case NoError:
+            case AssetRequest::Error::NoError:
                 _data = req->getData();
                 _result = Success;
                 break;
-            case AssetNotFound:
+            case AssetRequest::Error::NotFound:
                 _result = NotFound;
                 break;
             default:

libraries/networking/src/AssetUpload.cpp

@@ -46,23 +46,23 @@ void AssetUpload::start() {
         assetClient->uploadAsset(data, _extension, [this](AssetServerError error, const QString& hash){
             switch (error) {
                 case AssetServerError::NoError:
-                    _result = Success;
+                    _error = NoError;
                     break;
                 case AssetServerError::AssetTooLarge:
-                    _result = TooLarge;
+                    _error = TooLarge;
                     break;
                 case AssetServerError::PermissionDenied:
-                    _result = PermissionDenied;
+                    _error = PermissionDenied;
                     break;
                 default:
-                    _result = ErrorLoadingFile;
+                    _error = FileOpenError;
                     break;
             }
             emit finished(this, hash);
         });
     } else {
         // we couldn't open the file - set the error result
-        _result = ErrorLoadingFile;
+        _error = FileOpenError;
         
         // emit that we are done
         emit finished(this, QString());

libraries/networking/src/AssetUpload.h

@@ -26,12 +26,12 @@ class AssetUpload : public QObject {
     Q_OBJECT
 public:
     
-    enum Result {
-        Success = 0,
+    enum Error {
+        NoError = 0,
         Timeout,
         TooLarge,
         PermissionDenied,
-        ErrorLoadingFile
+        FileOpenError
     };
     
     AssetUpload(QObject* parent, const QString& filename);
@@ -40,7 +40,7 @@ public:
     
     const QString& getFilename() const { return _filename; }
     const QString& getExtension() const  { return _extension; }
-    const Result& getResult() const { return _result; }
+    const Error& getError() const { return _error; }
     
 signals:
     void finished(AssetUpload* upload, const QString& hash);
@@ -49,7 +49,7 @@ signals:
 private:
     QString _filename;
     QString _extension;
-    Result _result;
+    Error _error;
 };
 
 #endif // hifi_AssetUpload_h