1028 lines
34 KiB
C++
1028 lines
34 KiB
C++
/*
|
|
* QCMA: Cross-platform content manager assistant for the PS Vita
|
|
*
|
|
* Copyright (C) 2013 Codestation
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 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 General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "cmaevent.h"
|
|
#include "cmautils.h"
|
|
#include <locale.h>
|
|
|
|
#include <QDateTime>
|
|
#include <QDebug>
|
|
#include <QDir>
|
|
#include <QNetworkAccessManager>
|
|
#include <QSettings>
|
|
#include <QThread>
|
|
#include <QUrl>
|
|
|
|
QFile *CmaEvent::m_file = NULL;
|
|
|
|
static metadata_t g_thumbmeta = {0, 0, 0, NULL, NULL, 0, 0, 0, Thumbnail, {{17, 240, 136, 0, 1, 1.0f, 2}}, NULL};
|
|
|
|
CmaEvent::CmaEvent(Database *db, vita_device_t *s_device) :
|
|
m_device(s_device), m_db(db), is_active(true)
|
|
{
|
|
}
|
|
|
|
void CmaEvent::process()
|
|
{
|
|
qDebug("Starting event_thread: 0x%016" PRIxPTR, (uintptr_t)QThread::currentThreadId());
|
|
|
|
while(true) {
|
|
sema.acquire();
|
|
if(!isActive()) {
|
|
break;
|
|
}
|
|
|
|
QMutexLocker locker(&mutex);
|
|
processEvent();
|
|
}
|
|
qDebug("Finishing event_thread");
|
|
emit finishedEventLoop();
|
|
}
|
|
|
|
bool CmaEvent::isActive()
|
|
{
|
|
QMutexLocker locker(&active);
|
|
return is_active;
|
|
}
|
|
|
|
void CmaEvent::stop()
|
|
{
|
|
QMutexLocker locker(&active);
|
|
is_active = false;
|
|
sema.release();
|
|
}
|
|
|
|
void CmaEvent::setDevice(vita_device_t *device)
|
|
{
|
|
QMutexLocker locker(&mutex);
|
|
m_device = device;
|
|
}
|
|
|
|
void CmaEvent::setEvent(vita_event_t cma_event)
|
|
{
|
|
QMutexLocker locker(&mutex);
|
|
m_event = cma_event;
|
|
locker.unlock();
|
|
sema.release();
|
|
}
|
|
|
|
void CmaEvent::processEvent()
|
|
{
|
|
switch(m_event.Code) {
|
|
case PTP_EC_VITA_RequestSendNumOfObject:
|
|
vitaEventSendNumOfObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendObjectMetadata:
|
|
vitaEventSendObjectMetadata(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendObject:
|
|
vitaEventSendObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendHttpObjectFromURL:
|
|
vitaEventSendHttpObjectFromURL(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_Unknown1: // unimplemented
|
|
vitaEventUnimplementated(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendObjectStatus:
|
|
vitaEventSendObjectStatus(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendObjectThumb:
|
|
vitaEventSendObjectThumb(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestDeleteObject:
|
|
vitaEventDeleteObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestGetSettingInfo:
|
|
vitaEventGetSettingInfo(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendHttpObjectPropFromURL:
|
|
vitaEventSendHttpObjectPropFromURL(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendPartOfObject:
|
|
vitaEventSendPartOfObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestOperateObject:
|
|
vitaEventOperateObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestGetPartOfObject:
|
|
vitaEventGetPartOfObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendStorageSize:
|
|
vitaEventSendStorageSize(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestCheckExistance:
|
|
vitaEventCheckExistance(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestGetTreatObject:
|
|
vitaEventGetTreatObject(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendCopyConfirmationInfo:
|
|
vitaEventSendCopyConfirmationInfo(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendObjectMetadataItems:
|
|
vitaEventSendObjectMetadataItems(&m_event, m_event.Param1);
|
|
break;
|
|
case PTP_EC_VITA_RequestSendNPAccountInfo:
|
|
vitaEventSendNPAccountInfo(&m_event, m_event.Param1);
|
|
break;
|
|
default:
|
|
vitaEventUnimplementated(&m_event, m_event.Param1);
|
|
}
|
|
qDebug("Ended event, code: 0x%x, id: %d", m_event.Code, m_event.Param1);
|
|
}
|
|
|
|
quint16 CmaEvent::processAllObjects(metadata_t &parent_metadata, quint32 handle)
|
|
{
|
|
qDebug("Called %s, handle: %d, parent name: %s", Q_FUNC_INFO, handle, parent_metadata.name);
|
|
|
|
char *name;
|
|
int dataType;
|
|
quint32 *p_handles;
|
|
unsigned int p_len;
|
|
|
|
if(VitaMTP_GetObject_Info(m_device, handle, &name, &dataType) != PTP_RC_OK) {
|
|
qWarning("Cannot get object for handle %d", handle);
|
|
return PTP_RC_VITA_Invalid_Data;
|
|
}
|
|
|
|
if(dataType & Folder) {
|
|
if(VitaMTP_GetObject_Folder(m_device, handle, &p_handles, &p_len) != PTP_RC_OK) {
|
|
qWarning("Cannot get folder handles for handle %d", handle);
|
|
return PTP_RC_VITA_Invalid_Data;
|
|
}
|
|
} else {
|
|
|
|
}
|
|
|
|
int ohfi = m_db->getPathId(name, parent_metadata.ohfi);
|
|
|
|
if(ohfi > 0) {
|
|
const QString fullpath = m_db->getAbsolutePath(ohfi);
|
|
qDebug() << "Deleting" << fullpath;
|
|
removeRecursively(fullpath);
|
|
m_db->deleteEntry(ohfi);
|
|
}
|
|
|
|
QString fullpath = m_db->getAbsolutePath(parent_metadata.ohfi);
|
|
QDir dir(fullpath);
|
|
|
|
if(dataType & Folder) {
|
|
if(!dir.mkpath(name)) {
|
|
qWarning("Cannot create directory: %s", name);
|
|
free(name);
|
|
return PTP_RC_VITA_Failed_Operate_Object;
|
|
}
|
|
} else {
|
|
m_file = new QFile(dir.absoluteFilePath(name));
|
|
|
|
if(!m_file->open(QIODevice::WriteOnly)) {
|
|
qWarning("Cannot write to %s", name);
|
|
free(name);
|
|
delete m_file;
|
|
return PTP_RC_VITA_Invalid_Permission;
|
|
} else {
|
|
// the size gets ignored because we can also get it via info.size()
|
|
uint64_t size;
|
|
|
|
VitaMTP_GetObject_Callback(m_device, handle, &size, CmaEvent::writeCallback);
|
|
m_file->close();
|
|
delete m_file;
|
|
}
|
|
}
|
|
|
|
int new_ohfi = m_db->insertObjectEntry(fullpath, name, parent_metadata.ohfi);
|
|
qDebug("Added object %s with OHFI %i to database", name, new_ohfi);
|
|
free(name);
|
|
|
|
if(dataType & Folder) {
|
|
metadata_t folder_metadata;
|
|
m_db->getObjectMetadata(new_ohfi, folder_metadata);
|
|
folder_metadata.handle = handle;
|
|
|
|
for(unsigned int i = 0; i < p_len; i++) {
|
|
quint16 ret = processAllObjects(folder_metadata, p_handles[i]);
|
|
|
|
if(ret != PTP_RC_OK) {
|
|
qDebug("Deleteting object with OHFI %d", new_ohfi);
|
|
m_db->deleteEntry(new_ohfi);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
return PTP_RC_OK;
|
|
}
|
|
|
|
void CmaEvent::vitaEventGetTreatObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
treat_object_t treatObject;
|
|
|
|
if(VitaMTP_GetTreatObject(m_device, eventId, &treatObject) != PTP_RC_OK) {
|
|
qWarning("Cannot get information on object to get");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
metadata_t metadata;
|
|
|
|
if(!m_db->getObjectMetadata(treatObject.ohfiParent, metadata)) {
|
|
qWarning("Cannot find parent OHFI %d", treatObject.ohfiParent);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
return;
|
|
}
|
|
|
|
VitaMTP_ReportResult(m_device, eventId, processAllObjects(metadata, treatObject.handle));
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendCopyConfirmationInfo(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
copy_confirmation_info_t *info;
|
|
if(VitaMTP_SendCopyConfirmationInfoInit(m_device, eventId, &info) != PTP_RC_OK) {
|
|
qWarning("Error receiving initial information.");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
qint64 total_size = 0;
|
|
|
|
// check if the item is a single folder
|
|
if(info->count == 1) {
|
|
metadata_t obj_meta;
|
|
if(m_db->getObjectMetadata(info->ohfi[0], obj_meta)) {
|
|
// got a folder
|
|
if(obj_meta.dataType & Folder) {
|
|
metadata_t *meta_list = NULL;
|
|
if(m_db->getObjectList(info->ohfi[0], &meta_list)) {
|
|
int count = 0;
|
|
metadata_t *single_meta = meta_list;
|
|
// count files
|
|
while(single_meta) {
|
|
if(single_meta->dataType & File) {
|
|
count++;
|
|
}
|
|
single_meta = single_meta->next_metadata;
|
|
}
|
|
// create struct to hold all the file identifiers
|
|
info = (copy_confirmation_info_t *)malloc(sizeof(uint32_t) * count + sizeof(copy_confirmation_info_t));
|
|
single_meta = meta_list;
|
|
info->count = 0;
|
|
// copy all the file ohfi
|
|
while(single_meta) {
|
|
if(single_meta->dataType & File) {
|
|
info->ohfi[info->count] = single_meta->ohfi;
|
|
total_size += single_meta->size;
|
|
info->count++;
|
|
}
|
|
single_meta = single_meta->next_metadata;
|
|
}
|
|
|
|
}
|
|
m_db->freeMetadata(meta_list);
|
|
}
|
|
}
|
|
} else {
|
|
qint64 size;
|
|
|
|
for(quint32 i = 0; i < info->count; i++) {
|
|
if((size = m_db->getObjectSize(info->ohfi[i])) < 0) {
|
|
qWarning("Cannot find OHFI %d", info->ohfi[i]);
|
|
free(info);
|
|
return;
|
|
}
|
|
|
|
total_size += size;
|
|
}
|
|
}
|
|
|
|
if(VitaMTP_SendCopyConfirmationInfo(m_device, eventId, info, total_size) != PTP_RC_OK) {
|
|
qWarning("Error sending copy confirmation");
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
free(info);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendObjectMetadataItems(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
quint32 ohfi;
|
|
if(VitaMTP_SendObjectMetadataItems(m_device, eventId, &ohfi) != PTP_RC_OK) {
|
|
qWarning("Cannot get OHFI for retreving metadata");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
metadata_t metadata;
|
|
|
|
if(!m_db->getObjectMetadata(ohfi, metadata)) {
|
|
qWarning("Cannot find OHFI %d in database", ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
return;
|
|
}
|
|
|
|
metadata.next_metadata = NULL;
|
|
qDebug("Sending metadata for OHFI %d (%s)", ohfi, metadata.path);
|
|
|
|
quint16 ret = VitaMTP_SendObjectMetadata(m_device, eventId, &metadata);
|
|
if(ret != PTP_RC_OK) {
|
|
qWarning("Error sending metadata. Code: %04X", ret);
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendNPAccountInfo(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
// AFAIK, Sony hasn't even implemented this in their CMA
|
|
qWarning("Event 0x%x unimplemented!", cma_event->Code);
|
|
}
|
|
|
|
void CmaEvent::vitaEventUnimplementated(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qWarning("Unknown event not handled, code: 0x%x, id: %d", cma_event->Code, eventId);
|
|
qWarning("Param1: 0x%08X, Param2: 0x%08X, Param3: 0x%08X", cma_event->Param1, cma_event->Param2, cma_event->Param3);
|
|
}
|
|
|
|
void CmaEvent::vitaEventCancelTask(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
quint32 eventIdToCancel = cma_event->Param2;
|
|
qDebug("Cancelling event %d", eventIdToCancel);
|
|
quint16 ret = VitaMTP_CancelTask(m_device, eventIdToCancel);
|
|
|
|
// wait until the current event finishes so we can report the result to the device
|
|
|
|
qDebug("Waiting for send event to finish");
|
|
QMutexLocker locker(&mutex);
|
|
if(ret == PTP_RC_OK) {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendNumOfObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
int ohfi = cma_event->Param2;
|
|
int items = m_db->childObjectCount(ohfi);
|
|
|
|
if(VitaMTP_SendNumOfObject(m_device, eventId, items) != PTP_RC_OK) {
|
|
qWarning("Error occured receiving object count for OHFI parent %d", ohfi);
|
|
} else {
|
|
qDebug("Returned count of %d objects for OHFI parent %d", items, ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendObjectMetadata(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
browse_info_t browse;
|
|
|
|
if(VitaMTP_GetBrowseInfo(m_device, eventId, &browse) != PTP_RC_OK) {
|
|
qWarning("GetBrowseInfo failed");
|
|
return;
|
|
}
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
metadata_t *meta = NULL;
|
|
|
|
int count = m_db->getObjectMetadatas(browse.ohfiParent, &meta, browse.index, browse.numObjects); // if meta is null, will return empty XML
|
|
qDebug("Sending %i metadata filtered objects for OHFI %d", count, browse.ohfiParent);
|
|
|
|
if(VitaMTP_SendObjectMetadata(m_device, eventId, meta) != PTP_RC_OK) { // send all objects with OHFI parent
|
|
qWarning("Sending metadata for OHFI parent %d failed", browse.ohfiParent);
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
m_db->freeMetadata(meta);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
int ohfi = cma_event->Param2;
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
qDebug("Searching object with OHFI %d", ohfi);
|
|
|
|
metadata_t *metadata = NULL;
|
|
if(!m_db->getObjectList(ohfi, &metadata)) {
|
|
qWarning("Failed to find OHFI %d", ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
return;
|
|
}
|
|
|
|
metadata_t *start = metadata;
|
|
quint32 parentHandle = cma_event->Param3;
|
|
bool send_folder = metadata->dataType & Folder;
|
|
quint32 handle;
|
|
|
|
do {
|
|
quint64 len = metadata->size;
|
|
m_file = new QFile(m_db->getAbsolutePath(metadata->ohfi));
|
|
|
|
// read the file to send if it's not a directory
|
|
// if it is a directory, data and len are not used by VitaMTP
|
|
if(metadata->dataType & File) {
|
|
if(!m_file->open(QIODevice::ReadOnly)) {
|
|
qWarning() << "Failed to read" << m_file->fileName();
|
|
delete m_file;
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Not_Exist_Object);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// get the PTP object ID for the parent to put the object
|
|
// we know the parent has to be before the current node
|
|
// the first time this is called, parentHandle is left untouched
|
|
|
|
if(start != metadata) {
|
|
metadata_t parent_metadata;
|
|
m_db->getObjectMetadata(metadata->ohfiParent, parent_metadata);
|
|
parentHandle = parent_metadata.handle;
|
|
}
|
|
|
|
// send the data over
|
|
qDebug("Sending %s of %llu bytes to device", metadata->name, len);
|
|
qDebug("OHFI %d with handle 0x%08X", metadata->ohfi, parentHandle);
|
|
|
|
VitaMTP_RegisterCancelEventId(eventId);
|
|
quint16 ret = VitaMTP_SendObject_Callback(m_device, &parentHandle, &handle, metadata, &CmaEvent::readCallback);
|
|
if(ret != PTP_RC_OK) {
|
|
qWarning("Sending of %s failed. Code: %04X", metadata->name, ret);
|
|
if(ret == PTP_ERROR_CANCEL) {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_GeneralError);
|
|
}
|
|
m_file->close();
|
|
delete m_file;
|
|
return;
|
|
}
|
|
|
|
metadata->handle = handle;
|
|
|
|
if(metadata->dataType & File) {
|
|
m_file->close();
|
|
delete m_file;
|
|
}
|
|
|
|
// break early if only a file needs to be sent
|
|
if(!send_folder) {
|
|
break;
|
|
}
|
|
|
|
metadata = metadata->next_metadata;
|
|
|
|
} while(metadata && metadata->ohfiParent >= OHFI_BASE_VALUE); // get everything under this "folder"
|
|
|
|
m_db->freeMetadata(start);
|
|
|
|
VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, handle);
|
|
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Data); // TODO: Send thumbnail
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendHttpObjectFromURL(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
char *url;
|
|
if(VitaMTP_GetUrl(m_device, eventId, &url) != PTP_RC_OK) {
|
|
qWarning("Failed to receive URL");
|
|
return;
|
|
}
|
|
|
|
QString urlpath = QSettings().value("urlPath").toString();
|
|
QString basename = QFileInfo(QUrl(url).path()).fileName();
|
|
QFile file(QDir(urlpath).absoluteFilePath(basename));
|
|
|
|
QByteArray data;
|
|
QSettings settings;
|
|
|
|
bool offlineMode = settings.value("offlineMode", true).toBool();
|
|
|
|
if(!file.open(QIODevice::ReadOnly)) {
|
|
if(offlineMode && basename == "psp2-updatelist.xml") {
|
|
qDebug("Found request for update list. Sending cached data");
|
|
QFile res(":/main/resources/xml/psp2-updatelist.xml");
|
|
res.open(QIODevice::ReadOnly);
|
|
data = res.readAll();
|
|
|
|
// fetch country code from url
|
|
QString countryCode;
|
|
QStringList parts = QUrl(url).path().split('/');
|
|
if(parts.size() >= 2) {
|
|
parts.removeLast();
|
|
countryCode = parts.last();
|
|
qDebug() << "Detected country code from URL: " << countryCode;
|
|
|
|
if(countryCode != "us") {
|
|
QString regionTag = QString("<region id=\"%1\">").arg(countryCode);
|
|
data.replace("<region id=\"us\">", qPrintable(regionTag));
|
|
}
|
|
|
|
} else {
|
|
qWarning() << "No country code found in URL, defaulting to \"us\"";
|
|
}
|
|
|
|
} else if(!offlineMode) {
|
|
qDebug("URL: %s", url);
|
|
HTTPDownloader downloader(url);
|
|
QThread *http_thread = new QThread();
|
|
http_thread->setObjectName("http_thread");
|
|
connect(http_thread, SIGNAL(started()), &downloader, SLOT(downloadFile()));
|
|
connect(&downloader, SIGNAL(messageSent(QString)), SIGNAL(messageSent(QString)), Qt::DirectConnection);
|
|
downloader.moveToThread(http_thread);
|
|
http_thread->start();
|
|
|
|
int remote_size = (int)downloader.getFileSize();
|
|
|
|
if(remote_size != -1) {
|
|
// add the size of the file length to the total filesize
|
|
remote_size += 8;
|
|
qDebug("Sending %i bytes of data for HTTP request %s", remote_size, url);
|
|
|
|
if(VitaMTP_SendData_Callback(m_device, eventId, PTP_OC_VITA_SendHttpObjectFromURL, remote_size, HTTPDownloader::readCallback) != PTP_RC_OK) {
|
|
qWarning("Failed to send HTTP object");
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
} else {
|
|
qWarning("No valid content-length in header, aborting");
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Download);
|
|
}
|
|
|
|
free(url);
|
|
http_thread->quit();
|
|
http_thread->deleteLater();
|
|
return;
|
|
}
|
|
} else {
|
|
qDebug("Reading from local file");
|
|
data = file.readAll();
|
|
}
|
|
|
|
qDebug("Sending %i bytes of data for HTTP request %s", data.size(), url);
|
|
|
|
if(VitaMTP_SendHttpObjectFromURL(m_device, eventId, data.data(), data.size()) != PTP_RC_OK) {
|
|
qWarning("Failed to send HTTP object");
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
free(url);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendObjectStatus(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
object_status_t objectstatus;
|
|
|
|
if(VitaMTP_SendObjectStatus(m_device, eventId, &objectstatus) != PTP_RC_OK) {
|
|
qWarning("Failed to get information for object status.");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
qDebug("Checking for path %s under ohfi %i", objectstatus.title, objectstatus.ohfiRoot);
|
|
int ohfi = m_db->getPathId(objectstatus.title, objectstatus.ohfiRoot);
|
|
|
|
if(ohfi == 0) { // not in database, don't return metadata
|
|
qDebug("Object %s not in database (OHFI: %i). Sending OK response for non-existence", objectstatus.title, objectstatus.ohfiRoot);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
} else {
|
|
metadata_t metadata = metadata_t();
|
|
m_db->getObjectMetadata(ohfi, metadata);
|
|
metadata.next_metadata = NULL;
|
|
qDebug("Sending metadata for OHFI %d", ohfi);
|
|
|
|
if(VitaMTP_SendObjectMetadata(m_device, eventId, &metadata) != PTP_RC_OK) {
|
|
qWarning("Error sending metadata for %d", ohfi);
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
}
|
|
|
|
free(objectstatus.title);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendObjectThumb(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
int ohfi = cma_event->Param2;
|
|
metadata_t metadata;
|
|
|
|
if(!m_db->getObjectMetadata(ohfi, metadata)) {
|
|
qWarning("Cannot find OHFI %d in database.", ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
return;
|
|
}
|
|
|
|
QString fullpath = m_db->getAbsolutePath(ohfi);
|
|
QByteArray data = getThumbnail(fullpath, metadata.dataType, &g_thumbmeta);
|
|
|
|
if(data.size() == 0) {
|
|
qWarning() << "Cannot find/read thumbnail for" << fullpath;
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Data);
|
|
return;
|
|
}
|
|
|
|
//FIXME: remove this after fixing vitamtp
|
|
|
|
// workaround for the vitamtp locale bug
|
|
char *locale = strdup(setlocale(LC_ALL, NULL));
|
|
setlocale(LC_ALL, "C");
|
|
|
|
if(VitaMTP_SendObjectThumb(m_device, eventId, (metadata_t *)&g_thumbmeta, (uchar *)data.data(), data.size()) != PTP_RC_OK) {
|
|
qWarning("Error sending thumbnail");
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
// restore locale
|
|
setlocale(LC_ALL, locale);
|
|
free(locale);
|
|
}
|
|
|
|
void CmaEvent::vitaEventDeleteObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
int ohfi = cma_event->Param2;
|
|
metadata_t metadata;
|
|
|
|
if(!m_db->getObjectMetadata(ohfi, metadata)) {
|
|
qWarning("OHFI %d not found", ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
return;
|
|
}
|
|
|
|
QString fullpath = m_db->getAbsolutePath(ohfi);
|
|
qDebug() << QString("Deleting %1, OHFI: %2").arg(fullpath, QString::number(ohfi));
|
|
removeRecursively(fullpath);
|
|
m_db->deleteEntry(ohfi);
|
|
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
void CmaEvent::vitaEventGetSettingInfo(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
settings_info_t *settingsinfo;
|
|
if(VitaMTP_GetSettingInfo(m_device, eventId, &settingsinfo) != PTP_RC_OK) {
|
|
qWarning("Failed to get setting info from Vita.");
|
|
return;
|
|
}
|
|
|
|
qDebug("Current account id: %s", settingsinfo->current_account.accountId);
|
|
|
|
QSettings settings;
|
|
|
|
if(settings.value("lastAccountId").toString() != settingsinfo->current_account.accountId) {
|
|
m_db->setUUID(settingsinfo->current_account.accountId);
|
|
// set the database to be updated ASAP
|
|
emit refreshDatabase();
|
|
}
|
|
|
|
// free all the information
|
|
VitaMTP_Data_Free_Settings(settingsinfo);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendHttpObjectPropFromURL(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
char *url;
|
|
if(VitaMTP_GetUrl(m_device, eventId, &url) != PTP_RC_OK) {
|
|
qWarning("Failed to get URL");
|
|
return;
|
|
}
|
|
|
|
QString urlpath = QSettings().value("urlPath").toString();
|
|
QString basename = QFileInfo(url).fileName();
|
|
QFileInfo file(QDir(urlpath).absoluteFilePath(basename));
|
|
|
|
if(!file.exists()) {
|
|
qWarning("The file %s is not accesible", url);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Download);
|
|
free(url);
|
|
return;
|
|
}
|
|
|
|
QString timestamp = file.lastModified().toString();
|
|
|
|
http_object_prop_t httpobjectprop;
|
|
httpobjectprop.timestamp = timestamp.toUtf8().data();
|
|
httpobjectprop.timestamp_len = timestamp.toUtf8().size();
|
|
|
|
if(VitaMTP_SendHttpObjectPropFromURL(m_device, eventId, &httpobjectprop) != PTP_RC_OK) {
|
|
qWarning("Failed to send object properties");
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
free(url);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendPartOfObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
send_part_init_t part_init;
|
|
|
|
if(VitaMTP_SendPartOfObjectInit(m_device, eventId, &part_init) != PTP_RC_OK) {
|
|
qWarning("Cannot get information on object to send");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
QString fullpath = m_db->getAbsolutePath(part_init.ohfi);
|
|
|
|
if(fullpath.isNull()) {
|
|
qWarning("Cannot find object for OHFI %d", part_init.ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Context);
|
|
return;
|
|
}
|
|
|
|
QFile file(fullpath);
|
|
|
|
if(!file.open(QIODevice::ReadOnly)) {
|
|
qWarning() << "Cannot read" << fullpath;
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Not_Exist_Object);
|
|
return;
|
|
} else {
|
|
file.seek(part_init.offset);
|
|
QByteArray data = file.read(part_init.size);
|
|
qDebug() << QString("Sending %1 at file offset %2 for %3 bytes").arg(
|
|
fullpath, QString::number(part_init.offset), QString::number(part_init.size)
|
|
);
|
|
|
|
if(VitaMTP_SendPartOfObject(m_device, eventId, (unsigned char *)data.data(), data.size()) != PTP_RC_OK) {
|
|
qWarning("Failed to send part of object OHFI %d", part_init.ohfi);
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CmaEvent::vitaEventOperateObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
operate_object_t operateobject;
|
|
|
|
if(VitaMTP_OperateObject(m_device, eventId, &operateobject) != PTP_RC_OK) {
|
|
qWarning("Cannot get information on object to operate");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
QString fullpath = m_db->getAbsolutePath(operateobject.ohfi);
|
|
|
|
// end for renaming only
|
|
if(fullpath.isNull()) {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Not_Exist_Object);
|
|
return;
|
|
}
|
|
|
|
switch(operateobject.cmd) {
|
|
case VITA_OPERATE_CREATE_FOLDER: {
|
|
qDebug("Operate command %d: Create folder %s", operateobject.cmd, operateobject.title);
|
|
|
|
QDir dir(fullpath);
|
|
if(!dir.mkdir(operateobject.title)) {
|
|
qWarning("Unable to create temporary folder: %s", operateobject.title);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
|
|
} else {
|
|
int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi);
|
|
qDebug("Created folder %s with OHFI %d", operateobject.title, new_ohfi);
|
|
VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, new_ohfi);
|
|
}
|
|
break;
|
|
}
|
|
case VITA_OPERATE_CREATE_FILE: {
|
|
qDebug("Operate command %d: Create file %s", operateobject.cmd, operateobject.title);
|
|
|
|
QFile file(fullpath + QDir::separator() + operateobject.title);
|
|
if(!file.open(QIODevice::WriteOnly | QIODevice::Truncate)) {
|
|
qWarning("Unable to create temporary file: %s", operateobject.title);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
|
|
} else {
|
|
int new_ohfi = m_db->insertObjectEntry(fullpath, operateobject.title, operateobject.ohfi);
|
|
//qDebug("Created file %s with OHFI %d under parent %s", newobj->metadata.path, new_ohfi, root->metadata.path);
|
|
VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, new_ohfi);
|
|
}
|
|
break;
|
|
}
|
|
case VITA_OPERATE_RENAME: {
|
|
//qDebug("Operate command %d: Rename %s to %s", operateobject.cmd, root->metadata.name, operateobject.title);
|
|
|
|
m_db->renameObject(operateobject.ohfi, operateobject.title);
|
|
QString newpath = m_db->getAbsolutePath(operateobject.ohfi);
|
|
|
|
// rename in filesystem
|
|
if(!QFile(fullpath).rename(newpath)) {
|
|
qWarning("Unable to rename %s to %s", fullpath.toLocal8Bit().constData(), operateobject.title);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
|
|
break;
|
|
}
|
|
|
|
qDebug("Renamed OHFI %d from %s to %s", operateobject.ohfi, fullpath.toLocal8Bit().constData(), newpath.toLocal8Bit().constData());
|
|
VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_OK, operateobject.ohfi);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
qWarning("Operate command %d: Not implemented", operateobject.cmd);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Failed_Operate_Object);
|
|
break;
|
|
}
|
|
|
|
free(operateobject.title);
|
|
}
|
|
|
|
void CmaEvent::vitaEventGetPartOfObject(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
unsigned char *data;
|
|
send_part_init_t part_init;
|
|
|
|
if(VitaMTP_GetPartOfObject(m_device, eventId, &part_init, &data) != PTP_RC_OK) {
|
|
qWarning("Cannot get object from device");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
QString fullpath = m_db->getAbsolutePath(part_init.ohfi);
|
|
|
|
if(fullpath.isNull()) {
|
|
qWarning("Cannot find OHFI %d", part_init.ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
free(data);
|
|
return;
|
|
}
|
|
|
|
qDebug() << QString("Receiving %1 at offset %2 for %3 bytes").arg(
|
|
fullpath, QString::number(part_init.offset), QString::number(part_init.size)
|
|
);
|
|
|
|
QFile file(fullpath);
|
|
if(!file.open(QIODevice::ReadWrite)) {
|
|
qWarning() << "Cannot write to file" << fullpath;
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Permission);
|
|
} else {
|
|
file.seek(part_init.offset);
|
|
file.write((const char *)data, part_init.size);
|
|
m_db->setObjectSize(part_init.ohfi, part_init.size);
|
|
|
|
qDebug() << QString("Written %1 bytes to %2 at offset %3").arg(
|
|
QString::number(part_init.size), fullpath, QString::number(part_init.offset)
|
|
);
|
|
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
free(data);
|
|
}
|
|
|
|
void CmaEvent::vitaEventSendStorageSize(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
int ohfi = cma_event->Param2;
|
|
QString fullpath = m_db->getAbsolutePath(ohfi);
|
|
|
|
if(fullpath.isNull()) {
|
|
qWarning("Error: Cannot find OHFI %d", ohfi);
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_OHFI);
|
|
return;
|
|
} else {
|
|
QFile file(fullpath);
|
|
|
|
if(!file.exists()) {
|
|
// create the directory if doesn't exist so the query don't fail
|
|
qDebug() << "Creating" << fullpath;
|
|
|
|
if(!QDir(QDir::root()).mkpath(QDir(fullpath).absolutePath())) {
|
|
qWarning("Create directory failed");
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Permission);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
quint64 total;
|
|
quint64 free;
|
|
|
|
if(!getDiskSpace(fullpath, &free, &total)) {
|
|
qWarning("Cannot get disk space");
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Invalid_Permission);
|
|
return;
|
|
}
|
|
|
|
qDebug("Storage stats for drive containing OHFI %d, free: %llu, total: %llu", ohfi, free, total);
|
|
|
|
if(VitaMTP_SendStorageSize(m_device, eventId, total, free) != PTP_RC_OK) {
|
|
qWarning("Send storage size failed");
|
|
} else {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
}
|
|
|
|
void CmaEvent::vitaEventCheckExistance(vita_event_t *cma_event, int eventId)
|
|
{
|
|
qDebug("Event received in %s, code: 0x%x, id: %d", Q_FUNC_INFO, cma_event->Code, eventId);
|
|
|
|
int handle = cma_event->Param2;
|
|
existance_object_t existance;
|
|
|
|
if(VitaMTP_CheckExistance(m_device, handle, &existance) != PTP_RC_OK) {
|
|
qWarning("Cannot read information on object to be sent");
|
|
return;
|
|
}
|
|
|
|
QMutexLocker locker(&m_db->mutex);
|
|
|
|
int ohfi = m_db->getPathId(existance.name, 0);
|
|
|
|
if(ohfi == 0) {
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_VITA_Different_Object);
|
|
} else {
|
|
VitaMTP_ReportResultWithParam(m_device, eventId, PTP_RC_VITA_Same_Object, ohfi);
|
|
}
|
|
|
|
VitaMTP_ReportResult(m_device, eventId, PTP_RC_OK);
|
|
}
|
|
|
|
int CmaEvent::readCallback(unsigned char *data, unsigned long wantlen, unsigned long *gotlen)
|
|
{
|
|
int ret = m_file->read((char *)data, wantlen);
|
|
|
|
if(ret != -1) {
|
|
*gotlen = ret;
|
|
ret = PTP_RC_OK;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int CmaEvent::writeCallback(const unsigned char *data, unsigned long size, unsigned long *written)
|
|
{
|
|
int ret = m_file->write((const char *)data, size);
|
|
|
|
if(ret != -1) {
|
|
*written = ret;
|
|
ret = PTP_RC_OK;
|
|
}
|
|
|
|
return ret;
|
|
}
|