mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2024-12-24 11:16:11 +00:00
173 lines
8 KiB
C++
173 lines
8 KiB
C++
/*
|
|
* Copyright (c) Atmosphère-NX
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope 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 <haze.hpp>
|
|
#include <haze/ptp_data_builder.hpp>
|
|
#include <haze/ptp_data_parser.hpp>
|
|
#include <haze/ptp_responder_types.hpp>
|
|
|
|
namespace haze {
|
|
|
|
namespace {
|
|
|
|
PtpBuffers *GetBuffers() {
|
|
static constinit PtpBuffers buffers = {};
|
|
return std::addressof(buffers);
|
|
}
|
|
|
|
}
|
|
|
|
Result PtpResponder::Initialize(EventReactor *reactor, PtpObjectHeap *object_heap) {
|
|
m_object_heap = object_heap;
|
|
m_buffers = GetBuffers();
|
|
|
|
/* Configure fs proxy. */
|
|
m_fs.Initialize(reactor, fsdevGetDeviceFileSystem("sdmc"));
|
|
|
|
R_RETURN(m_usb_server.Initialize(std::addressof(MtpInterfaceInfo), SwitchMtpIdVendor, SwitchMtpIdProduct, reactor));
|
|
}
|
|
|
|
void PtpResponder::Finalize() {
|
|
m_usb_server.Finalize();
|
|
m_fs.Finalize();
|
|
}
|
|
|
|
Result PtpResponder::LoopProcess() {
|
|
while (true) {
|
|
/* Try to handle a request. */
|
|
R_TRY_CATCH(this->HandleRequest()) {
|
|
R_CATCH(haze::ResultStopRequested, haze::ResultFocusLost) {
|
|
/* If we encountered a stop condition, we're done.*/
|
|
R_THROW(R_CURRENT_RESULT);
|
|
}
|
|
R_CATCH_ALL() {
|
|
/* On other failures, try to handle another request. */
|
|
continue;
|
|
}
|
|
} R_END_TRY_CATCH;
|
|
|
|
/* Otherwise, handle the next request. */
|
|
/* ... */
|
|
}
|
|
}
|
|
|
|
Result PtpResponder::HandleRequest() {
|
|
ON_RESULT_FAILURE {
|
|
/* For general failure modes, the failure is unrecoverable. Close the session. */
|
|
this->ForceCloseSession();
|
|
};
|
|
|
|
R_TRY_CATCH(this->HandleRequestImpl()) {
|
|
R_CATCH(haze::ResultUnknownRequestType) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_GeneralError));
|
|
}
|
|
R_CATCH(haze::ResultSessionNotOpen) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_SessionNotOpen));
|
|
}
|
|
R_CATCH(haze::ResultOperationNotSupported) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_OperationNotSupported));
|
|
}
|
|
R_CATCH(haze::ResultInvalidStorageId) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_InvalidStorageId));
|
|
}
|
|
R_CATCH(haze::ResultInvalidObjectId) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_InvalidObjectHandle));
|
|
}
|
|
R_CATCH(haze::ResultUnknownPropertyCode) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_MtpObjectPropNotSupported));
|
|
}
|
|
R_CATCH(haze::ResultInvalidPropertyValue) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_MtpInvalidObjectPropValue));
|
|
}
|
|
R_CATCH(haze::ResultGroupSpecified) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_MtpSpecificationByGroupUnsupported));
|
|
}
|
|
R_CATCH(haze::ResultDepthSpecified) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_MtpSpecificationByDepthUnsupported));
|
|
}
|
|
R_CATCH(haze::ResultInvalidArgument) {
|
|
R_TRY(this->WriteResponse(PtpResponseCode_GeneralError));
|
|
}
|
|
R_CATCH_MODULE(fs) {
|
|
/* Errors from fs are typically recoverable. */
|
|
R_TRY(this->WriteResponse(PtpResponseCode_GeneralError));
|
|
}
|
|
} R_END_TRY_CATCH;
|
|
|
|
R_SUCCEED();
|
|
}
|
|
|
|
Result PtpResponder::HandleRequestImpl() {
|
|
PtpDataParser dp(m_buffers->usb_bulk_read_buffer, std::addressof(m_usb_server));
|
|
R_TRY(dp.Read(std::addressof(m_request_header)));
|
|
|
|
switch (m_request_header.type) {
|
|
case PtpUsbBulkContainerType_Command: R_RETURN(this->HandleCommandRequest(dp));
|
|
default: R_THROW(haze::ResultUnknownRequestType());
|
|
}
|
|
}
|
|
|
|
Result PtpResponder::HandleCommandRequest(PtpDataParser &dp) {
|
|
if (!m_session_open && m_request_header.code != PtpOperationCode_OpenSession && m_request_header.code != PtpOperationCode_GetDeviceInfo) {
|
|
R_THROW(haze::ResultSessionNotOpen());
|
|
}
|
|
|
|
switch (m_request_header.code) {
|
|
case PtpOperationCode_GetDeviceInfo: R_RETURN(this->GetDeviceInfo(dp)); break;
|
|
case PtpOperationCode_OpenSession: R_RETURN(this->OpenSession(dp)); break;
|
|
case PtpOperationCode_CloseSession: R_RETURN(this->CloseSession(dp)); break;
|
|
case PtpOperationCode_GetStorageIds: R_RETURN(this->GetStorageIds(dp)); break;
|
|
case PtpOperationCode_GetStorageInfo: R_RETURN(this->GetStorageInfo(dp)); break;
|
|
case PtpOperationCode_GetObjectHandles: R_RETURN(this->GetObjectHandles(dp)); break;
|
|
case PtpOperationCode_GetObjectInfo: R_RETURN(this->GetObjectInfo(dp)); break;
|
|
case PtpOperationCode_GetObject: R_RETURN(this->GetObject(dp)); break;
|
|
case PtpOperationCode_SendObjectInfo: R_RETURN(this->SendObjectInfo(dp)); break;
|
|
case PtpOperationCode_SendObject: R_RETURN(this->SendObject(dp)); break;
|
|
case PtpOperationCode_DeleteObject: R_RETURN(this->DeleteObject(dp)); break;
|
|
case PtpOperationCode_MtpGetObjectPropsSupported: R_RETURN(this->GetObjectPropsSupported(dp)); break;
|
|
case PtpOperationCode_MtpGetObjectPropDesc: R_RETURN(this->GetObjectPropDesc(dp)); break;
|
|
case PtpOperationCode_MtpGetObjectPropValue: R_RETURN(this->GetObjectPropValue(dp)); break;
|
|
case PtpOperationCode_MtpSetObjectPropValue: R_RETURN(this->SetObjectPropValue(dp)); break;
|
|
case PtpOperationCode_MtpGetObjPropList: R_RETURN(this->GetObjectPropList(dp)); break;
|
|
case PtpOperationCode_AndroidGetPartialObject64: R_RETURN(this->GetPartialObject64(dp)); break;
|
|
case PtpOperationCode_AndroidSendPartialObject: R_RETURN(this->SendPartialObject(dp)); break;
|
|
case PtpOperationCode_AndroidTruncateObject: R_RETURN(this->TruncateObject(dp)); break;
|
|
case PtpOperationCode_AndroidBeginEditObject: R_RETURN(this->BeginEditObject(dp)); break;
|
|
case PtpOperationCode_AndroidEndEditObject: R_RETURN(this->EndEditObject(dp)); break;
|
|
default: R_THROW(haze::ResultOperationNotSupported());
|
|
}
|
|
}
|
|
|
|
void PtpResponder::ForceCloseSession() {
|
|
if (m_session_open) {
|
|
m_session_open = false;
|
|
m_object_database.Finalize();
|
|
}
|
|
}
|
|
|
|
Result PtpResponder::WriteResponse(PtpResponseCode code, const void* data, size_t size) {
|
|
PtpDataBuilder db(m_buffers->usb_bulk_write_buffer, std::addressof(m_usb_server));
|
|
R_TRY(db.AddResponseHeader(m_request_header, code, size));
|
|
R_TRY(db.AddBuffer(reinterpret_cast<const u8*>(data), size));
|
|
R_RETURN(db.Commit());
|
|
}
|
|
|
|
Result PtpResponder::WriteResponse(PtpResponseCode code) {
|
|
PtpDataBuilder db(m_buffers->usb_bulk_write_buffer, std::addressof(m_usb_server));
|
|
R_TRY(db.AddResponseHeader(m_request_header, code, 0));
|
|
R_RETURN(db.Commit());
|
|
}
|
|
|
|
}
|