|
|
@@ -13,25 +13,74 @@ use constant FIRMWARE_POLL_INTERVAL => 3600 * (5 + rand());
|
|
|
use constant GITHUB_RELEASES_URI => "https://api.github.com/repos/sle118/squeezelite-esp32/releases";
|
|
|
use constant GITHUB_ASSET_URI => GITHUB_RELEASES_URI . "/assets/";
|
|
|
use constant GITHUB_DOWNLOAD_URI => "https://github.com/sle118/squeezelite-esp32/releases/download/";
|
|
|
-my $FW_DOWNLOAD_ID_REGEX = qr|plugins/SqueezeESP32/firmware/(-?\d+)|;
|
|
|
+use constant ESP32_STATUS_URI => "http://%s/status.json";
|
|
|
+
|
|
|
my $FW_DOWNLOAD_REGEX = qr|plugins/SqueezeESP32/firmware/([-a-z0-9-/.]+\.bin)$|i;
|
|
|
+my $FW_CUSTOM_REGEX = qr/^((?:squeezelite-esp32-)?custom\.bin)$/;
|
|
|
my $FW_FILENAME_REGEX = qr/^squeezelite-esp32-.*\.bin(\.tmp)?$/;
|
|
|
-my $FW_TAG_REGEX = qr/\/(ESP32-A1S|SqueezeAmp|I2S-4MFlash)\.(16|32)\.(\d+)\.(.*)\//;
|
|
|
+my $FW_TAG_REGEX = qr/\b(ESP32-A1S|SqueezeAmp|I2S-4MFlash)\.(16|32)\.(\d+)\.([-a-zA-Z0-9]+)\b/;
|
|
|
+
|
|
|
+use constant MAX_FW_IMAGE_SIZE => 10 * 1024 * 1024;
|
|
|
|
|
|
my $prefs = preferences('plugin.squeezeesp32');
|
|
|
my $log = logger('plugin.squeezeesp32');
|
|
|
|
|
|
+my $initialized;
|
|
|
+
|
|
|
sub init {
|
|
|
- Slim::Web::Pages->addRawFunction($FW_DOWNLOAD_ID_REGEX, \&handleFirmwareDownload);
|
|
|
- Slim::Web::Pages->addRawFunction($FW_DOWNLOAD_REGEX, \&handleFirmwareDownloadDirect);
|
|
|
+ my ($client) = @_;
|
|
|
+
|
|
|
+ if (!$initialized) {
|
|
|
+ $initialized = 1;
|
|
|
+ Slim::Web::Pages->addRawFunction($FW_DOWNLOAD_REGEX, \&handleFirmwareDownload);
|
|
|
+ Slim::Web::Pages->addRawFunction('plugins/SqueezeESP32/firmware/upload', \&handleFirmwareUpload);
|
|
|
+ }
|
|
|
|
|
|
# start checking for firmware updates
|
|
|
- Slim::Utils::Timers::setTimer(undef, Time::HiRes::time() + 30 + rand(30), \&prefetchFirmware);
|
|
|
+ Slim::Utils::Timers::setTimer($client, Time::HiRes::time() + 3.0 + rand(3.0), \&initFirmwareDownload);
|
|
|
+}
|
|
|
+
|
|
|
+sub initFirmwareDownload {
|
|
|
+ my ($client, $cb) = @_;
|
|
|
+
|
|
|
+ Slim::Utils::Timers::killTimers($client, \&initFirmwareDownload);
|
|
|
+
|
|
|
+ return unless preferences('server')->get('checkVersion') || $cb;
|
|
|
+
|
|
|
+ Slim::Networking::SimpleAsyncHTTP->new(
|
|
|
+ sub {
|
|
|
+ my $http = shift;
|
|
|
+ my $content = eval { from_json( $http->content ) };
|
|
|
+
|
|
|
+ if ($content && ref $content) {
|
|
|
+ my $releaseInfo = getFirmwareTag($content->{version});
|
|
|
+
|
|
|
+ if ($releaseInfo && ref $releaseInfo) {
|
|
|
+ prefetchFirmware($releaseInfo, $cb);
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ $cb->() if $cb;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ },
|
|
|
+ sub {
|
|
|
+ my ($http, $error) = @_;
|
|
|
+ $log->error("Failed to get releases from Github: $error");
|
|
|
+
|
|
|
+ $cb->() if $cb;
|
|
|
+ },
|
|
|
+ {
|
|
|
+ timeout => 10
|
|
|
+ }
|
|
|
+ )->get(sprintf(ESP32_STATUS_URI, $client->ip));
|
|
|
+
|
|
|
+ Slim::Utils::Timers::setTimer($client, Time::HiRes::time() + FIRMWARE_POLL_INTERVAL, \&initFirmwareDownload);
|
|
|
}
|
|
|
|
|
|
sub prefetchFirmware {
|
|
|
- Slim::Utils::Timers::killTimers(undef, \&prefetchFirmware);
|
|
|
- my $releaseInfo = $prefs->get('lastReleaseTagUsed');
|
|
|
+ my ($releaseInfo, $cb) = @_;
|
|
|
+
|
|
|
+ return unless $releaseInfo;
|
|
|
|
|
|
Slim::Networking::SimpleAsyncHTTP->new(
|
|
|
sub {
|
|
|
@@ -54,16 +103,21 @@ sub prefetchFirmware {
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- downloadFirmwareFile(sub {
|
|
|
- main::INFOLOG && $log->is_info && $log->info("Pre-cached firmware file: " . $_[0]);
|
|
|
- }, sub {
|
|
|
- my ($http, $error, $url, $code) = @_;
|
|
|
- $error ||= ($http && $http->error) || 'unknown error';
|
|
|
- $url ||= ($http && $http->url) || 'no URL';
|
|
|
+ my $customFwUrl = _urlFromPath('custom.bin') if $cb && -f _customFirmwareFile();
|
|
|
+
|
|
|
+ if ( ($url && $url =~ /^https?/) || $customFwUrl ) {
|
|
|
+ downloadFirmwareFile(sub {
|
|
|
+ main::INFOLOG && $log->is_info && $log->info("Pre-cached firmware file: " . $_[0]);
|
|
|
+ }, sub {
|
|
|
+ my ($http, $error, $url, $code) = @_;
|
|
|
+ $error ||= ($http && $http->error) || 'unknown error';
|
|
|
+ $url ||= ($http && $http->url) || 'no URL';
|
|
|
|
|
|
- $log->error(sprintf("Failed to get firmware image from Github: %s (%s)", $error || $http->error, $url));
|
|
|
- }, $url) if $url && $url =~ /^https?/;
|
|
|
+ $log->error(sprintf("Failed to get firmware image from Github: %s (%s)", $error || $http->error, $url));
|
|
|
+ }, $url) if $url;
|
|
|
|
|
|
+ $cb->($releaseInfo, _gh2lmsUrl($url), $customFwUrl) if $cb;
|
|
|
+ }
|
|
|
},
|
|
|
sub {
|
|
|
my ($http, $error) = @_;
|
|
|
@@ -74,9 +128,23 @@ sub prefetchFirmware {
|
|
|
cache => 1,
|
|
|
expires => 3600
|
|
|
}
|
|
|
- )->get(GITHUB_RELEASES_URI) if $releaseInfo;
|
|
|
+ )->get(GITHUB_RELEASES_URI);
|
|
|
+}
|
|
|
+
|
|
|
+sub _gh2lmsUrl {
|
|
|
+ my ($url) = @_;
|
|
|
+ my $ghPrefix = GITHUB_DOWNLOAD_URI;
|
|
|
+ my $baseUrl = Slim::Utils::Network::serverURL();
|
|
|
+ $url =~ s/$ghPrefix/$baseUrl\/plugins\/SqueezeESP32\/firmware\//;
|
|
|
+ return $url;
|
|
|
+}
|
|
|
|
|
|
- Slim::Utils::Timers::setTimer(undef, Time::HiRes::time() + FIRMWARE_POLL_INTERVAL, \&prefetchFirmware);
|
|
|
+sub _urlFromPath {
|
|
|
+ return sprintf('%s/plugins/SqueezeESP32/firmware/%s', Slim::Utils::Network::serverURL(), basename(shift));
|
|
|
+}
|
|
|
+
|
|
|
+sub _customFirmwareFile {
|
|
|
+ return catfile(scalar Slim::Utils::OSDetect::dirsFor('updates'), 'squeezelite-esp32-custom.bin');
|
|
|
}
|
|
|
|
|
|
sub handleFirmwareDownload {
|
|
|
@@ -88,13 +156,13 @@ sub handleFirmwareDownload {
|
|
|
_errorDownloading($httpClient, $response, @_);
|
|
|
};
|
|
|
|
|
|
- my $id;
|
|
|
- if (!defined $request || !(($id) = $request->uri =~ $FW_DOWNLOAD_ID_REGEX)) {
|
|
|
+ my $path;
|
|
|
+ if (!defined $request || !(($path) = $request->uri =~ $FW_DOWNLOAD_REGEX)) {
|
|
|
return $_errorDownloading->(undef, 'Invalid request', $request->uri, 400);
|
|
|
}
|
|
|
|
|
|
# this is the magic number used on the client to figure out whether the plugin does support download proxying
|
|
|
- if ($id == -99) {
|
|
|
+ if ($path eq '-check.bin' && $request->method eq 'HEAD') {
|
|
|
$response->code(204);
|
|
|
$response->header('Access-Control-Allow-Origin' => '*');
|
|
|
|
|
|
@@ -102,48 +170,20 @@ sub handleFirmwareDownload {
|
|
|
return Slim::Web::HTTP::closeHTTPSocket($httpClient);
|
|
|
}
|
|
|
|
|
|
- Slim::Networking::SimpleAsyncHTTP->new(
|
|
|
- sub {
|
|
|
- my $http = shift;
|
|
|
- my $content = eval { from_json( $http->content ) };
|
|
|
+ if ($path =~ $FW_CUSTOM_REGEX) {
|
|
|
+ my $firmwareFile = _customFirmwareFile();
|
|
|
|
|
|
- if (!$content || !ref $content) {
|
|
|
- $@ && $log->error("Failed to parse response: $@");
|
|
|
- return $_errorDownloading->($http);
|
|
|
- }
|
|
|
- elsif (!$content->{browser_download_url} || !$content->{name}) {
|
|
|
- return $_errorDownloading->($http, 'No download URL found');
|
|
|
- }
|
|
|
-
|
|
|
- downloadFirmwareFile(sub {
|
|
|
- my $firmwareFile = shift;
|
|
|
- $response->code(200);
|
|
|
- Slim::Web::HTTP::sendStreamingFile($httpClient, $response, 'application/octet-stream', $firmwareFile, undef, 1);
|
|
|
- }, $_errorDownloading, $content->{browser_download_url}, $content->{name});
|
|
|
- },
|
|
|
- $_errorDownloading,
|
|
|
- {
|
|
|
- timeout => 10,
|
|
|
- cache => 1,
|
|
|
- expires => 86400
|
|
|
+ if (! -f $firmwareFile) {
|
|
|
+ main::INFOLOG && $log->is_info && $log->info("Failed to find custom firmware build: $firmwareFile");
|
|
|
+ $response->code(404);
|
|
|
+ $httpClient->send_response($response);
|
|
|
+ return Slim::Web::HTTP::closeHTTPSocket($httpClient);
|
|
|
}
|
|
|
- )->get(GITHUB_ASSET_URI . $id);
|
|
|
-
|
|
|
- return;
|
|
|
-}
|
|
|
|
|
|
-sub handleFirmwareDownloadDirect {
|
|
|
- my ($httpClient, $response) = @_;
|
|
|
-
|
|
|
- my $request = $response->request;
|
|
|
-
|
|
|
- my $_errorDownloading = sub {
|
|
|
- _errorDownloading($httpClient, $response, @_);
|
|
|
- };
|
|
|
+ main::INFOLOG && $log->is_info && $log->info("Getting custom firmware build");
|
|
|
|
|
|
- my $path;
|
|
|
- if (!defined $request || !(($path) = $request->uri =~ $FW_DOWNLOAD_REGEX)) {
|
|
|
- return $_errorDownloading->(undef, 'Invalid request', $request->uri, 400);
|
|
|
+ $response->code(200);
|
|
|
+ return Slim::Web::HTTP::sendStreamingFile($httpClient, $response, 'application/octet-stream', $firmwareFile, undef, 1);
|
|
|
}
|
|
|
|
|
|
main::INFOLOG && $log->is_info && $log->info("Requesting firmware from: $path");
|
|
|
@@ -159,7 +199,7 @@ sub downloadFirmwareFile {
|
|
|
my ($cb, $ecb, $url, $name) = @_;
|
|
|
|
|
|
# keep track of the last firmware we requested, to prefetch it in the future
|
|
|
- _getFirmwareTag($url);
|
|
|
+ my $releaseInfo = getFirmwareTag($url);
|
|
|
|
|
|
$name ||= basename($url);
|
|
|
|
|
|
@@ -167,9 +207,21 @@ sub downloadFirmwareFile {
|
|
|
return $ecb->(undef, 'Unexpected firmware image name: ' . $name, $url, 400);
|
|
|
}
|
|
|
|
|
|
- my $updatesDir = Slim::Utils::OSDetect::dirsFor('updates');
|
|
|
+ my $updatesDir = _getTempDir();
|
|
|
my $firmwareFile = catfile($updatesDir, $name);
|
|
|
- Slim::Utils::Misc::deleteFiles($updatesDir, $FW_FILENAME_REGEX, $firmwareFile);
|
|
|
+
|
|
|
+ if (-f $firmwareFile) {
|
|
|
+ main::INFOLOG && $log->is_info && $log->info("Found uploaded firmware file $name");
|
|
|
+ return $cb->($firmwareFile);
|
|
|
+ }
|
|
|
+
|
|
|
+ $updatesDir = Slim::Utils::OSDetect::dirsFor('updates');
|
|
|
+ $firmwareFile = catfile($updatesDir, $name);
|
|
|
+
|
|
|
+ if ($releaseInfo) {
|
|
|
+ my $fileMatchRegex = join('-', '', $releaseInfo->{branch}, $releaseInfo->{model}, $releaseInfo->{res});
|
|
|
+ Slim::Utils::Misc::deleteFiles($updatesDir, $fileMatchRegex, $firmwareFile);
|
|
|
+ }
|
|
|
|
|
|
if (-f $firmwareFile) {
|
|
|
main::INFOLOG && $log->is_info && $log->info("Found cached firmware file");
|
|
|
@@ -188,7 +240,11 @@ sub downloadFirmwareFile {
|
|
|
|
|
|
return $cb->($firmwareFile);
|
|
|
},
|
|
|
- $ecb,
|
|
|
+ sub {
|
|
|
+ my ($http, $error) = @_;
|
|
|
+ $http->code(404) if $error =~ /\b404\b/;
|
|
|
+ $ecb->(@_);
|
|
|
+ },
|
|
|
{
|
|
|
saveAs => "$firmwareFile.tmp",
|
|
|
}
|
|
|
@@ -197,10 +253,10 @@ sub downloadFirmwareFile {
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
-sub _getFirmwareTag {
|
|
|
- my ($url) = @_;
|
|
|
+sub getFirmwareTag {
|
|
|
+ my ($info) = @_;
|
|
|
|
|
|
- if (my ($model, $resolution, $version, $branch) = $url =~ $FW_TAG_REGEX) {
|
|
|
+ if (my ($model, $resolution, $version, $branch) = $info =~ $FW_TAG_REGEX) {
|
|
|
my $releaseInfo = {
|
|
|
model => $model,
|
|
|
res => $resolution,
|
|
|
@@ -208,8 +264,6 @@ sub _getFirmwareTag {
|
|
|
branch => $branch
|
|
|
};
|
|
|
|
|
|
- $prefs->set('lastReleaseTagUsed', $releaseInfo);
|
|
|
-
|
|
|
return $releaseInfo;
|
|
|
}
|
|
|
}
|
|
|
@@ -233,5 +287,123 @@ sub _errorDownloading {
|
|
|
Slim::Web::HTTP::closeHTTPSocket($httpClient);
|
|
|
};
|
|
|
|
|
|
+sub handleFirmwareUpload {
|
|
|
+ my ($httpClient, $response) = @_;
|
|
|
+
|
|
|
+ my $request = $response->request;
|
|
|
+ my $result = {};
|
|
|
+
|
|
|
+ my $t = Time::HiRes::time();
|
|
|
+
|
|
|
+ main::INFOLOG && $log->is_info && $log->info("New firmware image to upload. Size: " . formatMB($request->content_length));
|
|
|
+
|
|
|
+ if ( $request->method !~ /HEAD|OPTIONS|POST/ ) {
|
|
|
+ $log->error("Invalid HTTP verb: " . $request->method);
|
|
|
+ $result = {
|
|
|
+ error => 'Invalid request.',
|
|
|
+ code => 400,
|
|
|
+ };
|
|
|
+ }
|
|
|
+ elsif ( $request->content_length > MAX_FW_IMAGE_SIZE ) {
|
|
|
+ $log->error("Upload data is too large: " . $request->content_length);
|
|
|
+ $result = {
|
|
|
+ error => string('PLUGIN_DNDPLAY_FILE_TOO_LARGE', formatMB($request->content_length), formatMB(MAX_FW_IMAGE_SIZE)),
|
|
|
+ code => 413,
|
|
|
+ };
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ my $ct = $request->header('Content-Type');
|
|
|
+ my ($boundary) = $ct =~ /boundary=(.*)/;
|
|
|
+
|
|
|
+ my ($uploadedFwFh, $filename, $inUpload, $buf);
|
|
|
+
|
|
|
+ # open a pseudo-filehandle to the uploaded data ref for further processing
|
|
|
+ open TEMP, '<', $request->content_ref;
|
|
|
+
|
|
|
+ while (<TEMP>) {
|
|
|
+ if ( Time::HiRes::time - $t > 0.2 ) {
|
|
|
+ main::idleStreams();
|
|
|
+ $t = Time::HiRes::time();
|
|
|
+ }
|
|
|
+
|
|
|
+ # a new part starts - reset some variables
|
|
|
+ if ( /--\Q$boundary\E/i ) {
|
|
|
+ $filename = '';
|
|
|
+
|
|
|
+ if ($buf) {
|
|
|
+ $buf =~ s/\r\n$//;
|
|
|
+ print $uploadedFwFh $buf if $uploadedFwFh;
|
|
|
+ }
|
|
|
+
|
|
|
+ close $uploadedFwFh if $uploadedFwFh;
|
|
|
+ $inUpload = undef;
|
|
|
+ }
|
|
|
+
|
|
|
+ # write data to file handle
|
|
|
+ elsif ( $inUpload && $uploadedFwFh ) {
|
|
|
+ print $uploadedFwFh $buf if defined $buf;
|
|
|
+ $buf = $_;
|
|
|
+ }
|
|
|
+
|
|
|
+ # we got an uploaded file name
|
|
|
+ elsif ( /filename="(.+?)"/i ) {
|
|
|
+ $filename = $1;
|
|
|
+ main::INFOLOG && $log->is_info && $log->info("New file to upload: $filename")
|
|
|
+ }
|
|
|
+
|
|
|
+ # we got the separator after the upload file name: file data comes next. Open a file handle to write the data to.
|
|
|
+ elsif ( $filename && /^\s*$/ ) {
|
|
|
+ $inUpload = 1;
|
|
|
+
|
|
|
+ $uploadedFwFh = File::Temp->new(
|
|
|
+ DIR => _getTempDir(),
|
|
|
+ SUFFIX => '.bin',
|
|
|
+ TEMPLATE => 'squeezelite-esp32-upload-XXXXXX',
|
|
|
+ UNLINK => 0,
|
|
|
+ ) or $log->warn("Failed to open file: $@");
|
|
|
+
|
|
|
+ binmode $uploadedFwFh;
|
|
|
+
|
|
|
+ # remove file after a few minutes
|
|
|
+ Slim::Utils::Timers::setTimer($uploadedFwFh->filename, Time::HiRes::time() + 15 * 60, sub { unlink shift });
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ close TEMP;
|
|
|
+ close $uploadedFwFh if $uploadedFwFh;
|
|
|
+
|
|
|
+ main::idleStreams();
|
|
|
+
|
|
|
+ if (!$result->{error}) {
|
|
|
+ $result->{url} = _urlFromPath($uploadedFwFh->filename);
|
|
|
+ $result->{size} = -s $uploadedFwFh->filename;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ $log->error($result->{error}) if $result->{error};
|
|
|
+
|
|
|
+ my $content = to_json($result);
|
|
|
+ $response->header( 'Content-Length' => length($content) );
|
|
|
+ $response->code($result->{code} || 200);
|
|
|
+ $response->header('Connection' => 'close');
|
|
|
+ $response->content_type('application/json');
|
|
|
+
|
|
|
+ Slim::Web::HTTP::addHTTPResponse( $httpClient, $response, \$content );
|
|
|
+}
|
|
|
+
|
|
|
+my $tempDir;
|
|
|
+sub _getTempDir {
|
|
|
+ return $tempDir if $tempDir;
|
|
|
+
|
|
|
+ eval { $tempDir = Slim::Utils::Misc::getTempDir() }; # LMS 8.2+ only
|
|
|
+ $tempDir ||= File::Temp::tempdir(CLEANUP => 1, DIR => preferences('server')->get('cachedir'));
|
|
|
+
|
|
|
+ return $tempDir;
|
|
|
+}
|
|
|
+
|
|
|
+sub formatMB {
|
|
|
+ return Slim::Utils::Misc::delimitThousands(int($_[0] / 1024 / 1024)) . 'MB';
|
|
|
+}
|
|
|
+
|
|
|
|
|
|
1;
|
philippe44