rekushi/switchnote
1
1 Fork 0
Code Issues Packages Projects Releases 1 Wiki Activity
Files
main
switchnote/source/audio_upload_server.cpp
T
Rekushi 558a387b6e Add files via upload
2026-10-29 03:55:40 +00:00

702 lines
40 KiB
C++
Raw Permalink Blame History

#include "audio_upload_server.hpp"
#include <algorithm>
#include <array>
#include <atomic>
#include <cctype>
#include <cstdio>
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <map>
#include <new>
#include <sstream>
#include <string>
#include <vector>
#ifdef __SWITCH__
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <switch.h>
#include <unistd.h>
#endif
namespace {
#ifdef __SWITCH__
constexpr std::uint16_t kUploadPort = 8766;
constexpr std::size_t kMaxHeaderBytes = 16 * 1024;
constexpr std::size_t kMaxBgmUploadBytes = 32 * 1024 * 1024;
constexpr std::size_t kMaxSfxUploadBytes = 3 * 1024 * 1024;
struct ServerState {
Thread thread{};
std::atomic<bool> running{false};
std::atomic<bool> connected{false};
std::atomic<int> pendingTrack{-1};
std::atomic<int> uploadOutcome{0}; // 0 idle, 1 processing, 2 imported, 3 rejected
std::atomic<int> activeClient{-1};
bool photoTransfer = false;
int listenFd = -1;
std::string bindAddress;
std::string uploadDirectory;
std::string assetsRoot;
std::string noteSingular = "Switchnote";
std::string sessionCode;
std::string sessionToken;
std::uint32_t pairedAddress = 0;
unsigned int failedCodeAttempts = 0;
};
constexpr unsigned int kMaxCodeAttempts = 8;
bool validPairCode(const std::string& code) {
if (code.size() != 7 || code[3] != '-') return false;
for (std::size_t i = 0; i < code.size(); ++i)
if (i != 3 && (code[i] < '0' || code[i] > '9')) return false;
return true;
}
std::string hexToken(const std::array<std::uint8_t, 32>& bytes) {
constexpr char digits[] = "0123456789abcdef";
std::string token;
token.reserve(bytes.size() * 2);
for (const std::uint8_t byte : bytes) {
token.push_back(digits[byte >> 4]);
token.push_back(digits[byte & 15]);
}
return token;
}
std::string trim(std::string value) {
while (!value.empty() && (value.back() == '\r' || value.back() == '\n' ||
value.back() == ' ' || value.back() == '\t')) value.pop_back();
std::size_t first = 0;
while (first < value.size() && (value[first] == ' ' || value[first] == '\t')) ++first;
return value.substr(first);
}
std::string lower(std::string value) {
for (char& c : value) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
return value;
}
bool constantTimeEqual(const std::string& a, const std::string& b) {
const std::size_t length = std::max(a.size(), b.size());
unsigned int difference = static_cast<unsigned int>(a.size() ^ b.size());
for (std::size_t i = 0; i < length; ++i) {
const unsigned char av = i < a.size() ? static_cast<unsigned char>(a[i]) : 0;
const unsigned char bv = i < b.size() ? static_cast<unsigned char>(b[i]) : 0;
difference |= static_cast<unsigned int>(av ^ bv);
}
return difference == 0;
}
bool sendAll(int fd, const void* bytes, std::size_t length) {
const auto* data = static_cast<const std::uint8_t*>(bytes);
std::size_t sent = 0;
while (sent < length) {
const ssize_t count = ::send(fd, data + sent, length - sent, 0);
if (count <= 0) return false;
sent += static_cast<std::size_t>(count);
}
return true;
}
void respond(int fd, int status, const char* reason, const std::string& type,
const void* body, std::size_t length, bool html = false) {
std::ostringstream headers;
headers << "HTTP/1.1 " << status << ' ' << reason << "\r\n"
<< "Content-Type: " << type << "\r\n"
<< "Content-Length: " << length << "\r\n"
<< "Connection: close\r\n"
<< "Cache-Control: no-store\r\n"
<< "X-Content-Type-Options: nosniff\r\n"
<< "Referrer-Policy: no-referrer\r\n"
<< "X-Frame-Options: DENY\r\n";
if (html) headers << "Content-Security-Policy: default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; img-src 'self' blob:; font-src 'self'; connect-src 'self'; base-uri 'none'; form-action 'self'\r\n";
headers << "\r\n";
const std::string header = headers.str();
sendAll(fd, header.data(), header.size());
if (length) sendAll(fd, body, length);
}
void respondText(int fd, int status, const char* reason, const char* body) {
respond(fd, status, reason, "text/plain; charset=utf-8", body, std::strlen(body));
}
std::string htmlEscape(const std::string& value) {
std::string escaped;
escaped.reserve(value.size());
for (const char c : value) {
switch (c) {
case '&': escaped += "&amp;"; break;
case '<': escaped += "&lt;"; break;
case '>': escaped += "&gt;"; break;
case '\"': escaped += "&quot;"; break;
case '\'': escaped += "&#39;"; break;
default: escaped.push_back(c); break;
}
}
return escaped;
}
std::string jsEscape(const std::string& value) {
std::string escaped;
escaped.reserve(value.size());
for (const char c : value) {
if (c == '\\' || c == '\'') escaped.push_back('\\');
if (c == '\n' || c == '\r') continue;
escaped.push_back(c);
}
return escaped;
}
std::string brandedPage(std::string page, const std::string& noteSingular) {
const std::string name = noteSingular.empty() ? "Switchnote" : noteSingular;
auto replaceAll = [&](const std::string& from, const std::string& to) {
std::size_t at = 0;
while ((at = page.find(from, at)) != std::string::npos) {
page.replace(at, from.size(), to);
at += to.size();
}
};
replaceAll("' </style></head>", "</style></head>");
replaceAll("'Adding audio to the {{NOTE}}…'", "'Adding audio to the {{NOTE_JS}}…'");
replaceAll("'Audio added to the {{NOTE}}.'", "'Audio added to the {{NOTE_JS}}.'");
replaceAll("Photo added to the Switchnote.", "Photo added to the {{NOTE_JS}}.");
replaceAll("{{NOTE}}", htmlEscape(name));
replaceAll("{{NOTE_JS}}", jsEscape(name));
return page;
}
std::string uploadPage(const std::string& noteSingular) {
return brandedPage(R"HTML(<!doctype html>
<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>Audio upload</title>
<style>
@font-face{font-family:Seurat;src:url('/assets/font') format('opentype')}*{box-sizing:border-box}body{margin:0;min-height:100vh;color:#252831;font-family:Seurat,'Trebuchet MS',sans-serif;background-color:#fff;background-image:linear-gradient(#d9e2ef 1px,transparent 1px),linear-gradient(90deg,#d9e2ef 1px,transparent 1px);background-size:24px 24px}.shell{max-width:920px;margin:5vh auto;padding:22px}.card{background:#fff;border:2px solid #e2e6f2;border-radius:18px;box-shadow:0 5px 0 #d5d8df,0 8px 20px #18243b22;padding:clamp(20px,4vw,34px)}p{line-height:1.5;color:#6c7280;margin-top:0}label{display:block;font-weight:700;margin:18px 0 7px}input,select{width:100%;font:inherit;padding:13px 14px;border:2px solid #d8dce5;border-radius:12px;background:#fff;color:#252831}input:focus,select:focus{outline:3px solid #ffb77e;border-color:#ff751e}.row{display:grid;grid-template-columns:1fr 1fr;gap:16px}.button{margin-top:22px;width:100%;padding:14px 18px;border:3px solid #fff;border-radius:28px;background:#ffd3a6;color:#ee6818;font:inherit;font-weight:700;box-shadow:0 4px 0 #cfd2d8,0 0 0 2px #e5e7ec;cursor:pointer;transition:transform .12s,box-shadow .12s}.button:hover{transform:translateY(-2px)}.button:active{transform:translateY(2px);box-shadow:0 1px 0 #cfd2d8}.button:disabled{opacity:.5;cursor:not-allowed}.status{min-height:28px;margin:15px 0 0;padding:10px 12px;border-radius:10px;background:#f1f3f8;color:#555d6b}.status.ok{background:#effbdd;color:#4e8d2c}.status.error{background:#fff0ed;color:#ba342d}.connected{margin:0 0 20px;padding:15px 18px;border-radius:13px;background:#effbdd;color:#4e8d2c;font-size:20px}.footer{margin:20px 4px;color:#697183;font-size:13px}[hidden]{display:none!important}@media(max-width:620px){.shell{padding:14px}.row{grid-template-columns:1fr}.card{padding:20px}}
</style></head><body><main class="shell">
<section class="card"><div id="pair"><p>Enter the code shown in Sound on your Nintendo Switch.</p>
<label for="code">Connection code</label><input id="code" inputmode="numeric" pattern="[0-9]*" autocomplete="one-time-code" maxlength="7" placeholder="000-000"><div id="pairStatus" class="status" role="status">Enter all six digits to connect.</div></div>
<div id="connected" class="connected" role="status" hidden>Connected to Nintendo Switch</div>
<div id="uploadPanel" hidden><p>Choose a track and an audio file. BGM is trimmed to 60 seconds; each sound effect is trimmed to 2 seconds.</p>
<div class="row"><div><label for="track">Track</label><select id="track"><option value="0">BGM · Music</option><option value="1">SE1 · Sound effect 1</option><option value="2">SE2 · Sound effect 2</option><option value="3">SE3 · Sound effect 3</option></select></div><div><label for="file">Audio file</label><input id="file" type="file" accept="audio/*,.wav,.mp3,.ogg,.m4a,.flac"></div></div>
<button class="button" id="send">Upload to Switch</button><div id="status" class="status" role="status">Ready to upload.</div></div></section>
<div class="footer">Ver 0.1.51</div></main>
<script>
'use strict';
const $ = id => document.getElementById(id);
let sessionToken = '', connecting = false;
function message(value, kind = '') {
const target = sessionToken ? $('status') : $('pairStatus');
target.className = 'status' + (kind ? ' ' + kind : ''); target.textContent = value;
}
async function connect(code) {
if (connecting || sessionToken) return;
connecting = true; message('Connecting…');
try {
const response = await fetch('/api/connect', {method: 'POST', headers: {'Authorization': 'Bearer ' + code}});
const reply = (await response.text()).trim();
if (!response.ok) throw new Error(reply || 'Could not connect to the Switch.');
if (!/^[a-f0-9]{64}$/.test(reply)) throw new Error('The Switch sent an invalid connection response.');
if ($('code').value !== code) return;
sessionToken = reply;
$('pair').hidden = true; $('connected').hidden = false; $('uploadPanel').hidden = false;
} catch (error) { message(error.message || 'Could not connect to the Switch.', 'error'); }
finally { connecting = false; }
}
$('code').addEventListener('input', () => {
const digits = $('code').value.replace(/\D/g, '').slice(0, 6);
$('code').value = digits.length > 3 ? digits.slice(0, 3) + '-' + digits.slice(3) : digits;
if (digits.length === 6) connect($('code').value);
});
async function wavFromFile(file, maxSeconds) {
const AudioContextClass = window.AudioContext || window.webkitAudioContext;
if (!AudioContextClass) throw new Error('This browser cannot convert audio. Try a WAV file in a newer browser.');
const context = new AudioContextClass({sampleRate: 48000});
try {
const audio = await context.decodeAudioData(await file.arrayBuffer());
if (!audio.length) throw new Error('This audio file is empty.');
const frames = Math.min(audio.length, Math.floor(maxSeconds * audio.sampleRate));
const data = new ArrayBuffer(44 + frames * 4), view = new DataView(data);
const write = (at, text) => { for (let i = 0; i < text.length; i++) view.setUint8(at + i, text.charCodeAt(i)); };
write(0, 'RIFF'); view.setUint32(4, data.byteLength - 8, true); write(8, 'WAVE');
write(12, 'fmt '); view.setUint32(16, 16, true); view.setUint16(20, 1, true);
view.setUint16(22, 2, true); view.setUint32(24, audio.sampleRate, true);
view.setUint32(28, audio.sampleRate * 4, true); view.setUint16(32, 4, true);
view.setUint16(34, 16, true); write(36, 'data'); view.setUint32(40, frames * 4, true);
const left = audio.getChannelData(0), right = audio.getChannelData(Math.min(1, audio.numberOfChannels - 1));
for (let i = 0; i < frames; i++) {
view.setInt16(44 + i * 4, Math.round(Math.max(-1, Math.min(1, left[i])) * 32767), true);
view.setInt16(46 + i * 4, Math.round(Math.max(-1, Math.min(1, right[i])) * 32767), true);
}
return {blob: new Blob([data], {type: 'audio/wav'}), trimmed: frames < audio.length};
} finally { await context.close(); }
}
$('send').addEventListener('click', async () => {
const file = $('file').files[0], track = $('track').value;
if (!sessionToken) { message('Connect to the Switch first.', 'error'); return; }
if (!file) { message('Choose an audio file first.', 'error'); return; }
if (file.size > 128 * 1024 * 1024) { message('This source file is too large to prepare in the browser.', 'error'); return; }
$('send').disabled = true;
try {
message('Preparing ' + file.name + '…');
const prepared = await wavFromFile(file, track === '0' ? 60 : 2), wav = prepared.blob;
if (wav.size > (track === '0' ? 32 : 3) * 1024 * 1024)
throw new Error('The converted audio is too large for this track.');
message('Sending ' + file.name + '…');
const headers = {'Authorization': 'Bearer ' + sessionToken};
const response = await fetch('/api/upload', {method: 'POST', headers: {...headers, 'Content-Type': 'audio/wav', 'X-Audio-Track': track}, body: wav});
const reply = await response.text();
if (!response.ok) throw new Error(reply || 'Upload failed.');
message('Adding audio to the {{NOTE}}…');
let outcome = 'processing';
for (let i = 0; i < 60 && outcome === 'processing'; i++) {
await new Promise(resolve => setTimeout(resolve, 250));
const result = await fetch('/api/status', {headers});
if (!result.ok) throw new Error('The Sound menu was closed before import finished.');
outcome = (await result.text()).trim();
}
if (outcome !== 'imported') throw new Error(outcome === 'processing' ? 'The Switch is still processing this audio. Check the Sound menu.' : 'The Switch could not add this audio. Check its duration.');
message(prepared.trimmed ? 'Audio added and trimmed to ' + (track === '0' ? '60' : '2') + ' seconds.' : 'Audio added to the {{NOTE}}.', 'ok'); $('file').value = '';
} catch (error) { message(error.message || 'Upload failed. Keep this page open and try again.', 'error'); }
finally { $('send').disabled = false; }
});
</script></body></html>)HTML", noteSingular);
}
std::string photoPage(const std::string& noteSingular) {
return brandedPage(R"HTML(<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Photo import</title><style>
@font-face{font-family:Seurat;src:url('/assets/font') format('opentype')}*{box-sizing:border-box}body{margin:0;min-height:100vh;color:#252831;font-family:Seurat,'Trebuchet MS',sans-serif;background:#fff;background-image:linear-gradient(#d9e2ef 1px,transparent 1px),linear-gradient(90deg,#d9e2ef 1px,transparent 1px);background-size:24px 24px}.shell{max-width:1000px;margin:3vh auto;padding:18px}.card{background:#fff;border:2px solid #e2e6f2;border-radius:18px;box-shadow:0 5px 0 #d5d8df,0 8px 20px #18243b22;padding:clamp(18px,3vw,30px)}h1{margin:0 0 8px;font-size:30px}p{line-height:1.45;color:#6c7280;margin-top:0}.connected{padding:12px 15px;border-radius:13px;background:#effbdd;color:#4e8d2c;font-size:18px}label{display:block;margin:13px 0 6px}input,select{width:100%;padding:10px 12px;border:2px solid #d8dce5;border-radius:10px;background:white;color:#252831;font:inherit}.grid{display:grid;grid-template-columns:minmax(220px,1fr) minmax(300px,1.25fr);gap:20px}.opts{display:grid;grid-template-columns:1fr 1fr;gap:10px}.preview{width:100%;aspect-ratio:5/3;background-color:#e8ecf4;background-image:linear-gradient(45deg,#cad0dc 25%,transparent 25%),linear-gradient(-45deg,#cad0dc 25%,transparent 25%),linear-gradient(45deg,transparent 75%,#cad0dc 75%),linear-gradient(-45deg,transparent 75%,#cad0dc 75%);background-size:20px 20px;background-position:0 0,0 10px,10px -10px,-10px 0;border:2px solid #d8dce5;border-radius:12px;image-rendering:pixelated}.button{margin-top:16px;width:100%;padding:13px;border:3px solid white;border-radius:28px;background:#ffd3a6;color:#ee6818;font:inherit;box-shadow:0 4px 0 #cfd2d8,0 0 0 2px #e5e7ec;cursor:pointer}.button:disabled{opacity:.5}.status{margin-top:12px;padding:10px;border-radius:9px;background:#f1f3f8;color:#555d6b}.status.error{background:#fff0ed;color:#ba342d}[hidden]{display:none!important}@media(max-width:680px){.grid{grid-template-columns:1fr}.opts{grid-template-columns:1fr 1fr}}
' </style></head><body><main class="shell"><section class="card"><h1>Photo Import</h1><div id="pair"><p>Connect to your {{NOTE}} over local Wi-Fi using the code shown on screen.</p><label>Connection code</label><input id="code" inputmode="numeric" maxlength="7" placeholder="000-000"><div id="pairStatus" class="status">Enter all six digits to connect.</div></div><div id="panel" hidden><div class="connected">Connected to Nintendo Switch</div><p>Choose an image and adjust its canvas placement before sending it to the current {{NOTE}}.</p><div class="grid"><div><label>Image</label><input id="file" type="file" accept="image/png,image/jpeg,image/webp"><div class="opts"><div><label>Color mode</label><select id="mode"><option value="color">Full color</option><option value="ink">Single ink</option></select></div><div><label>Dithering</label><select id="dither"><option value="none">None</option><option value="ordered">Ordered</option></select></div><div><label>Ink color</label><input id="ink" type="color" value="#171717"></div><div><label>Layer</label><select id="layer"><option value="0">A · Back</option><option value="1">B</option><option value="2">C</option><option value="3">D · Front</option></select></div><div><label>Size</label><input id="size" type="range" min="25" max="200" value="100"><small id="sizeLabel">100%</small></div><div><label>Position X</label><input id="px" type="range" min="-300" max="300" value="0"></div><div><label>Position Y</label><input id="py" type="range" min="-180" max="180" value="0"></div></div></div><div><canvas id="preview" class="preview" width="600" height="360"></canvas><button class="button" id="send" disabled>Upload to {{NOTE}}</button><div id="status" class="status">Choose an image to preview.</div></div></div></section></main><script>
'use strict';const $=id=>document.getElementById(id);let token='',busy=false,img=null;const canvas=$('preview'),ctx=canvas.getContext('2d',{willReadFrequently:true});function say(v,e=false){$('status').textContent=v;$('status').className='status'+(e?' error':'')}async function pair(code){if(busy||token)return;busy=true;$('pairStatus').textContent='Connecting…';try{const r=await fetch('/api/connect',{method:'POST',headers:{Authorization:'Bearer '+code}}),t=(await r.text()).trim();if(!r.ok)throw Error(t||'Could not connect.');if(!/^[a-f0-9]{64}$/.test(t))throw Error('Invalid Switch response.');token=t;$('pair').hidden=true;$('panel').hidden=false}catch(e){$('pairStatus').textContent=e.message;$('pairStatus').className='status error'}finally{busy=false}}$('code').addEventListener('input',()=>{const d=$('code').value.replace(/\D/g,'').slice(0,6);$('code').value=d.length>3?d.slice(0,3)+'-'+d.slice(3):d;if(d.length===6)pair($('code').value)});function render(){if(!img)return;ctx.clearRect(0,0,600,360);const s=Number($('size').value)/100,w=img.width*s,h=img.height*s,x=(600-w)/2+Number($('px').value),y=(360-h)/2+Number($('py').value);ctx.drawImage(img,x,y,w,h);const im=ctx.getImageData(0,0,600,360),p=im.data,ink=$('ink').value.match(/[a-f\d]{2}/gi).map(v=>parseInt(v,16)),mono=$('mode').value==='ink',ordered=$('dither').value==='ordered',bayer=[0,8,2,10,12,4,14,6,3,11,1,9,15,7,13,5];for(let yy=0;yy<360;yy++)for(let xx=0;xx<600;xx++){const i=(yy*600+xx)*4;if(p[i+3]<24){p[i+3]=0;continue}if(mono){let l=(p[i]*299+p[i+1]*587+p[i+2]*114)/1000;if(ordered)l+=(bayer[(yy&3)*4+(xx&3)]-7.5)*12;const v=l<128?0:255;p[i]=v?255:ink[0];p[i+1]=v?255:ink[1];p[i+2]=v?255:ink[2]}else if(ordered){const t=(bayer[(yy&3)*4+(xx&3)]-7.5)*3;p[i]=Math.max(0,Math.min(255,p[i]+t));p[i+1]=Math.max(0,Math.min(255,p[i+1]+t));p[i+2]=Math.max(0,Math.min(255,p[i+2]+t))}}ctx.putImageData(im,0,0);$('sizeLabel').textContent=$('size').value+'%';$('send').disabled=!token}$('file').addEventListener('change',()=>{const f=$('file').files[0];if(!f)return;if(f.size>16*1024*1024){say('Choose an image under 16 MB.',true);return}img=new Image();img.onload=()=>{render();say('Preview ready.');};img.onerror=()=>say('Could not read that image.',true);img.src=URL.createObjectURL(f)});['mode','dither','ink','size','px','py'].forEach(id=>$(id).addEventListener('input',render));$('send').addEventListener('click',async()=>{if(!token||!img||busy)return;busy=true;$('send').disabled=true;try{render();say('Preparing image…');const data=ctx.getImageData(0,0,600,360).data;const r=await fetch('/api/photo',{method:'POST',headers:{Authorization:'Bearer '+token,'Content-Type':'application/octet-stream','X-Photo-Layer':$('layer').value,'X-Photo-Mode':$('mode').value,'X-Photo-Dither':$('dither').value,'X-Photo-Size':$('size').value,'X-Photo-X':$('px').value,'X-Photo-Y':$('py').value},body:data});const t=await r.text();if(!r.ok)throw Error(t||'Upload failed.');say('Image sent. Importing to the selected layer…');let o='processing';for(let i=0;i<80&&o==='processing';i++){await new Promise(a=>setTimeout(a,250));const q=await fetch('/api/status',{headers:{Authorization:'Bearer '+token}});if(!q.ok)throw Error('Photo menu closed before import finished.');o=(await q.text()).trim()}if(o!=='imported')throw Error(o==='rejected'?'Could not import this image.':'Switch is still processing the image.');say('Photo added to the Switchnote.');}catch(e){say(e.message||'Upload failed.',true)}finally{busy=false;$('send').disabled=false}});
</script></body></html>)HTML", noteSingular);
}
bool readAsset(const std::string& path, std::vector<char>& result, const std::string& root) {
std::string relative;
if (path == "/assets/font") relative = "/fonts/FOT-Seurat.otf";
else return false;
std::ifstream file(root + relative, std::ios::binary | std::ios::ate);
if (!file) return false;
const std::streamoff length = file.tellg();
if (length <= 0 || length > 4 * 1024 * 1024) return false;
result.resize(static_cast<std::size_t>(length));
file.seekg(0, std::ios::beg);
return static_cast<bool>(file.read(result.data(), length));
}
bool receiveHeaders(int fd, std::string& request, std::size_t& bodyStart) {
char buffer[4096];
while (true) {
const std::size_t split = request.find("\r\n\r\n");
if (split != std::string::npos) { bodyStart = split + 4; return true; }
if (request.size() >= kMaxHeaderBytes) return false;
const ssize_t count = ::recv(fd, buffer, sizeof(buffer), 0);
if (count <= 0) return false;
request.append(buffer, static_cast<std::size_t>(count));
if (request.size() > kMaxHeaderBytes + 4096) return false;
}
}
bool storeUpload(ServerState* state, int fd, int track, const std::string& request,
std::size_t bodyStart, std::size_t bodySize) {
const std::string base = state->uploadDirectory + "/audio-transfer-" + std::to_string(track);
const std::string temporary = base + ".part";
const std::string destination = base + ".wav";
std::ofstream output(temporary, std::ios::binary | std::ios::trunc);
if (!output) {
respondText(fd, 500, "Internal Server Error", "Could not save the upload.");
return false;
}
const std::size_t inBuffer = std::min(bodySize, request.size() - bodyStart);
char wavHeader[12]{};
std::size_t headerCount = 0;
auto append = [&](const char* bytes, std::size_t count) {
const std::size_t prefix = std::min(count, sizeof(wavHeader) - headerCount);
if (prefix) { std::memcpy(wavHeader + headerCount, bytes, prefix); headerCount += prefix; }
output.write(bytes, static_cast<std::streamsize>(count));
};
append(request.data() + bodyStart, inBuffer);
std::size_t received = inBuffer;
char buffer[8192];
while (output && received < bodySize && state->running.load(std::memory_order_acquire)) {
const std::size_t needed = std::min(sizeof(buffer), bodySize - received);
const ssize_t count = ::recv(fd, buffer, needed, 0);
if (count <= 0) break;
append(buffer, static_cast<std::size_t>(count));
received += static_cast<std::size_t>(count);
}
if (!output || received != bodySize) {
output.close();
std::remove(temporary.c_str());
respondText(fd, 400, "Bad Request", "Upload was interrupted.");
return false;
}
if (std::memcmp(wavHeader, "RIFF", 4) != 0 || std::memcmp(wavHeader + 8, "WAVE", 4) != 0) {
output.close();
std::remove(temporary.c_str());
respondText(fd, 415, "Unsupported Media Type", "This file is not a valid WAV container.");
return false;
}
output.flush();
output.close();
// This path is reserved for the transient PC transfer. A previous session
// can leave it behind if the app was closed during import.
std::remove(destination.c_str());
if (!output || std::rename(temporary.c_str(), destination.c_str()) != 0) {
std::remove(temporary.c_str());
respondText(fd, 500, "Internal Server Error", "Could not finalize the upload.");
return false;
}
state->uploadOutcome.store(1, std::memory_order_release);
state->pendingTrack.store(track, std::memory_order_release);
const char* success = "WAV received by Switch. Importing now.";
respond(fd, 200, "OK", "text/plain; charset=utf-8", success, std::strlen(success));
return true;
}
bool storePhotoUpload(ServerState* state, int fd, const std::string& request,
std::size_t bodyStart, std::size_t bodySize,
const std::map<std::string, std::string>& headers) {
auto number = [&](const char* key, int low, int high, int& value) {
const auto found = headers.find(key);
if (found == headers.end() || found->second.empty()) return false;
char* end = nullptr;
const long parsed = std::strtol(found->second.c_str(), &end, 10);
if (!end || *end || parsed < low || parsed > high) return false;
value = static_cast<int>(parsed);
return true;
};
int layer = 0, size = 0, offsetX = 0, offsetY = 0;
if (headers.find("x-photo-mode") == headers.end() || headers.find("x-photo-dither") == headers.end() ||
!number("x-photo-layer", 0, 3, layer) || !number("x-photo-size", 25, 200, size) ||
!number("x-photo-x", -300, 300, offsetX) || !number("x-photo-y", -180, 180, offsetY) ||
(headers.at("x-photo-mode") != "color" && headers.at("x-photo-mode") != "ink") ||
(headers.at("x-photo-dither") != "none" && headers.at("x-photo-dither") != "ordered")) {
respondText(fd, 400, "Bad Request", "Photo options are invalid.");
return false;
}
constexpr std::size_t expectedBytes = 600U * 360U * 4U;
if (bodySize != expectedBytes || request.size() < bodyStart || request.size() - bodyStart > bodySize) {
respondText(fd, 400, "Bad Request", "Processed photo has an invalid canvas size.");
return false;
}
const std::string path = state->uploadDirectory + "/photo-transfer.rgba";
const std::string configPath = state->uploadDirectory + "/photo-transfer.cfg";
std::ofstream output(path, std::ios::binary | std::ios::trunc);
if (!output) { respondText(fd, 500, "Internal Server Error", "Could not open the photo transfer file."); return false; }
const std::size_t buffered = std::min(bodySize, request.size() - bodyStart);
output.write(request.data() + bodyStart, static_cast<std::streamsize>(buffered));
std::size_t received = buffered;
char buffer[8192];
while (output && received < bodySize && state->running.load(std::memory_order_acquire)) {
const ssize_t count = ::recv(fd, buffer, std::min(sizeof(buffer), bodySize - received), 0);
if (count <= 0) break;
output.write(buffer, count);
received += static_cast<std::size_t>(count);
}
output.flush();
output.close();
if (!output || received != bodySize) { std::remove(path.c_str()); respondText(fd, 400, "Bad Request", "Photo upload was interrupted."); return false; }
std::ofstream config(configPath, std::ios::binary | std::ios::trunc);
config << layer << '\n' << headers.at("x-photo-mode") << '\n' << headers.at("x-photo-dither")
<< '\n' << size << '\n' << offsetX << '\n' << offsetY << '\n';
config.flush();
if (!config) { config.close(); std::remove(path.c_str()); respondText(fd, 500, "Internal Server Error", "Could not save photo options."); return false; }
state->uploadOutcome.store(1, std::memory_order_release);
state->pendingTrack.store(4, std::memory_order_release);
const char* success = "Photo received by Switch. Importing now.";
respond(fd, 200, "OK", "text/plain; charset=utf-8", success, std::strlen(success));
return true;
}
void serveClient(ServerState* state, int fd, std::uint32_t clientAddress) {
timeval timeout{};
timeout.tv_sec = 4;
::setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
::setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
std::string request;
std::size_t bodyStart = 0;
if (!receiveHeaders(fd, request, bodyStart)) {
respondText(fd, 400, "Bad Request", "Invalid HTTP request.");
return;
}
const std::size_t lineEnd = request.find("\r\n");
if (lineEnd == std::string::npos) return;
std::istringstream firstLine(request.substr(0, lineEnd));
std::string method, path, version;
firstLine >> method >> path >> version;
if (version != "HTTP/1.1" && version != "HTTP/1.0") {
respondText(fd, 400, "Bad Request", "Invalid HTTP version.");
return;
}
std::map<std::string, std::string> headers;
std::size_t cursor = lineEnd + 2;
while (cursor < bodyStart - 2) {
const std::size_t end = request.find("\r\n", cursor);
if (end == std::string::npos || end == cursor) break;
const std::size_t colon = request.find(':', cursor);
if (colon == std::string::npos || colon >= end) {
respondText(fd, 400, "Bad Request", "Malformed request header.");
return;
}
headers[lower(trim(request.substr(cursor, colon - cursor)))] = trim(request.substr(colon + 1, end - colon - 1));
cursor = end + 2;
}
if (method == "GET" && path == "/") {
const std::string page = state->photoTransfer ? photoPage(state->noteSingular) : uploadPage(state->noteSingular);
respond(fd, 200, "OK", "text/html; charset=utf-8", page.data(), page.size(), true);
return;
}
if (method == "GET" && path == "/assets/font") {
std::vector<char> asset;
if (!readAsset(path, asset, state->assetsRoot)) {
respondText(fd, 404, "Not Found", "Asset not found.");
return;
}
respond(fd, 200, "OK", "font/otf", asset.data(), asset.size());
return;
}
const bool pairing = method == "POST" && path == "/api/connect";
const bool photoUpload = state->photoTransfer && method == "POST" && path == "/api/photo";
if (!pairing && !photoUpload && !((method == "POST" && path == "/api/upload") || (method == "GET" && path == "/api/status"))) {
respondText(fd, 404, "Not Found", "Not found.");
return;
}
const std::string auth = headers["authorization"];
if (pairing) {
if (state->connected.load(std::memory_order_acquire) && clientAddress != state->pairedAddress) {
respondText(fd, 409, "Conflict", "Another PC is already connected. Reopen Sound to pair again.");
return;
}
if (state->failedCodeAttempts >= kMaxCodeAttempts) {
respondText(fd, 429, "Too Many Requests", "Too many incorrect codes. Reopen Sound for a new code.");
return;
}
if (!constantTimeEqual(auth, "Bearer " + state->sessionCode)) {
++state->failedCodeAttempts;
respondText(fd, 403, "Forbidden", "Connection code is incorrect.");
return;
}
state->pairedAddress = clientAddress;
state->connected.store(true, std::memory_order_release);
respond(fd, 200, "OK", "text/plain; charset=utf-8",
state->sessionToken.data(), state->sessionToken.size());
return;
}
if (!state->connected.load(std::memory_order_acquire) || clientAddress != state->pairedAddress ||
!constantTimeEqual(auth, "Bearer " + state->sessionToken)) {
respondText(fd, 403, "Forbidden", "Connect to the Switch first.");
return;
}
if (method == "GET") {
const int outcome = state->uploadOutcome.load(std::memory_order_acquire);
respondText(fd, 200, "OK", outcome == 2 ? "imported" : outcome == 3 ? "rejected" : "processing");
return;
}
if (state->pendingTrack.load(std::memory_order_acquire) >= 0) {
respondText(fd, 409, "Conflict", "The previous upload is still being added on the Switch.");
return;
}
if (headers.find("transfer-encoding") != headers.end()) {
respondText(fd, 400, "Bad Request", "Chunked upload is not supported.");
return;
}
char* end = nullptr;
const std::string lengthHeader = headers["content-length"];
const unsigned long long bodyLength = std::strtoull(lengthHeader.c_str(), &end, 10);
if (photoUpload) {
constexpr unsigned long long photoBytes = 600ULL * 360ULL * 4ULL;
if (lengthHeader.empty() || !end || *end != '\0' || bodyLength != photoBytes ||
lower(headers["content-type"]) != "application/octet-stream") {
respondText(fd, 413, "Payload Too Large", "Send a processed 600 by 360 RGBA photo.");
return;
}
storePhotoUpload(state, fd, request, bodyStart, static_cast<std::size_t>(bodyLength), headers);
return;
}
if (lengthHeader.empty() || !end || *end != '\0' || bodyLength < 12 || bodyLength > kMaxBgmUploadBytes) {
respondText(fd, 413, "Payload Too Large", "Choose a WAV under 32 MiB.");
return;
}
const std::string trackHeader = headers["x-audio-track"];
if (trackHeader.size() != 1 || trackHeader[0] < '0' || trackHeader[0] > '3') {
respondText(fd, 400, "Bad Request", "Choose BGM or one of SE1-SE3.");
return;
}
const int track = trackHeader[0] - '0';
if (track > 0 && bodyLength > kMaxSfxUploadBytes) {
respondText(fd, 413, "Payload Too Large", "A sound-effect WAV must be under 3 MiB.");
return;
}
const std::string contentType = lower(headers["content-type"]);
if (contentType != "audio/wav" && contentType != "audio/x-wav" && contentType != "application/octet-stream") {
respondText(fd, 415, "Unsupported Media Type", "Select a WAV audio file.");
return;
}
storeUpload(state, fd, track, request, bodyStart, static_cast<std::size_t>(bodyLength));
}
void serverThread(void* argument) {
auto* state = static_cast<ServerState*>(argument);
while (state->running.load(std::memory_order_acquire)) {
fd_set readers;
FD_ZERO(&readers);
FD_SET(state->listenFd, &readers);
timeval wait{};
wait.tv_sec = 0;
wait.tv_usec = 100000;
const int ready = ::select(state->listenFd + 1, &readers, nullptr, nullptr, &wait);
if (ready <= 0) continue;
if (!state->running.load(std::memory_order_acquire)) break;
sockaddr_in peer{};
socklen_t peerSize = sizeof(peer);
const int client = ::accept(state->listenFd, reinterpret_cast<sockaddr*>(&peer), &peerSize);
if (client < 0) continue;
state->activeClient.store(client, std::memory_order_release);
serveClient(state, client, peer.sin_addr.s_addr);
::shutdown(client, SHUT_RDWR);
::close(client);
state->activeClient.store(-1, std::memory_order_release);
}
}
#endif
} // namespace
AudioUploadServer::AudioUploadServer() = default;
AudioUploadServer::~AudioUploadServer() { stop(); }
bool AudioUploadServer::start(const std::string& bindAddress, const std::string& uploadDirectory,
const std::string& assetsRoot, const std::string& sessionCode,
std::string& error, bool photoTransfer,
const std::string& noteSingular) {
stop();
#ifdef __SWITCH__
if (!validPairCode(sessionCode) || uploadDirectory.empty()) {
error = "Invalid upload server configuration.";
return false;
}
auto* state = new (std::nothrow) ServerState{};
if (!state) { error = "Not enough memory to open the sound server."; return false; }
state->bindAddress = bindAddress;
state->uploadDirectory = uploadDirectory;
state->assetsRoot = assetsRoot;
state->noteSingular = noteSingular;
state->sessionCode = sessionCode;
state->photoTransfer = photoTransfer;
std::array<std::uint8_t, 32> tokenBytes{};
if (R_FAILED(csrngGetRandomBytes(tokenBytes.data(), tokenBytes.size()))) {
delete state;
error = "Could not create a secure upload session.";
return false;
}
state->sessionToken = hexToken(tokenBytes);
state->listenFd = ::socket(AF_INET, SOCK_STREAM, 0);
if (state->listenFd < 0) { delete state; error = "Could not create the upload socket."; return false; }
int reuse = 1;
::setsockopt(state->listenFd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
sockaddr_in address{};
address.sin_family = AF_INET;
address.sin_port = htons(kUploadPort);
if (::inet_pton(AF_INET, bindAddress.c_str(), &address.sin_addr) != 1 ||
::bind(state->listenFd, reinterpret_cast<sockaddr*>(&address), sizeof(address)) != 0 ||
::listen(state->listenFd, 2) != 0) {
::close(state->listenFd);
delete state;
error = "Could not listen on " + bindAddress + ":" + std::to_string(kUploadPort) + ".";
return false;
}
state->running.store(true, std::memory_order_release);
const Result created = threadCreate(&state->thread, serverThread, state, nullptr, 0x10000, 0x3B, -2);
if (R_FAILED(created)) {
state->running.store(false, std::memory_order_release);
::close(state->listenFd);
delete state;
error = "Could not start the upload service thread.";
return false;
}
if (R_FAILED(threadStart(&state->thread))) {
state->running.store(false, std::memory_order_release);
::close(state->listenFd);
threadClose(&state->thread);
delete state;
error = "Could not start the upload service thread.";
return false;
}
impl_ = state;
error.clear();
return true;
#else
(void)bindAddress; (void)uploadDirectory; (void)assetsRoot; (void)sessionCode; (void)photoTransfer; (void)noteSingular;
error = "The Switch upload server is available in the homebrew app.";
return false;
#endif
}
void AudioUploadServer::stop() {
#ifdef __SWITCH__
auto* state = static_cast<ServerState*>(impl_);
if (!state) return;
state->running.store(false, std::memory_order_release);
const int client = state->activeClient.load(std::memory_order_acquire);
if (client >= 0) ::shutdown(client, SHUT_RDWR);
threadWaitForExit(&state->thread);
if (state->listenFd >= 0) ::close(state->listenFd);
threadClose(&state->thread);
delete state;
impl_ = nullptr;
#endif
}
bool AudioUploadServer::isRunning() const {
#ifdef __SWITCH__
const auto* state = static_cast<const ServerState*>(impl_);
return state && state->running.load(std::memory_order_acquire);
#else
return false;
#endif
}
bool AudioUploadServer::isConnected() const {
#ifdef __SWITCH__
const auto* state = static_cast<const ServerState*>(impl_);
return state && state->connected.load(std::memory_order_acquire);
#else
return false;
#endif
}
bool AudioUploadServer::takeCompletedUpload(int& track) {
#ifdef __SWITCH__
auto* state = static_cast<ServerState*>(impl_);
if (!state) return false;
track = state->pendingTrack.load(std::memory_order_acquire);
return track >= 0 && track <= 4;
#else
(void)track;
return false;
#endif
}
void AudioUploadServer::finishCompletedUpload(bool success) {
#ifdef __SWITCH__
auto* state = static_cast<ServerState*>(impl_);
if (state) {
state->uploadOutcome.store(success ? 2 : 3, std::memory_order_release);
state->pendingTrack.store(-1, std::memory_order_release);
}
#else
(void)success;
#endif
}
Reference in new issue View Git Blame Copy Permalink