push sheeet

pkgs/by-name/ts/ts-warp/package.nix

@@ -0,0 +1,32 @@
+{
+  fetchFromGitHub,
+  lib,
+  stdenv,
+  which,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "ts-warp";
+  version = "1.5.8";
+
+  src = fetchFromGitHub {
+    owner = "mezantrop";
+    repo = "ts-warp";
+    tag = finalAttrs.version;
+    hash = "sha256-eHw8OUBlrptLzMhG4udjYH/WIXbu+3G9IVLUwO4JlpU=";
+  };
+
+  nativeBuildInputs = [ which ];
+
+  env.PREFIX = "$(out)";
+
+  meta = {
+    description = "Transparent proxy server and traffic wrapper";
+    homepage = "https://github.com/mezantrop/ts-warp";
+    license = lib.licenses.bsd2;
+    platforms = lib.platforms.unix;
+    changelog = "https://github.com/mezantrop/ts-warp/blob/${finalAttrs.version}/CHANGELOG.md";
+    maintainers = with lib.maintainers; [ heywoodlh ];
+    mainProgram = "ts-warp";
+  };
+})

pkgs/by-name/ts/ts/package.nix

@@ -0,0 +1,31 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  sendmailPath ? "/run/wrappers/bin/sendmail",
+}:
+
+stdenv.mkDerivation rec {
+  pname = "ts";
+  version = "1.0.3";
+
+  installPhase = ''make install "PREFIX=$out"'';
+
+  patchPhase = ''
+    sed -i s,/usr/sbin/sendmail,${sendmailPath}, mail.c ts.1
+  '';
+
+  src = fetchurl {
+    url = "https://viric.name/~viric/soft/ts/ts-${version}.tar.gz";
+    sha256 = "sha256-+oMzEVQ9xTW2DLerg8ZKte4xEo26qqE93jQZhOVCtCg=";
+  };
+
+  meta = with lib; {
+    homepage = "http://vicerveza.homeunix.net/~viric/soft/ts";
+    description = "Task spooler - batch queue";
+    license = licenses.gpl2Only;
+    maintainers = [ ];
+    platforms = platforms.all;
+    mainProgram = "ts";
+  };
+}

pkgs/by-name/ts/ts_query_ls/package.nix

@@ -0,0 +1,33 @@
+{
+  lib,
+  rustPlatform,
+  fetchFromGitHub,
+  cmake,
+}:
+let
+  pname = "ts_query_ls";
+  version = "3.11.1";
+in
+rustPlatform.buildRustPackage {
+  inherit pname version;
+
+  src = fetchFromGitHub {
+    owner = "ribru17";
+    repo = "ts_query_ls";
+    rev = "v${version}";
+    hash = "sha256-SQyy/7M9karkLI2smx6KnJWWuP3qWA4gKh1F/gIGRjQ=";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  cargoHash = "sha256-9I/SiZTG/QAy1iBjWvleTqkile2K0h9TtW90+lILWQ0=";
+
+  meta = {
+    description = "LSP implementation for Tree-sitter's query files";
+    homepage = "https://github.com/ribru17/ts_query_ls";
+    changelog = "https://github.com/ribru17/ts_query_ls/releases/tag/v${version}";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ ribru17 ];
+    mainProgram = "ts_query_ls";
+  };
+}

pkgs/by-name/ts/tscli/package.nix

@@ -0,0 +1,43 @@
+{
+  lib,
+  stdenv,
+  buildGoModule,
+  fetchFromGitHub,
+  installShellFiles,
+}:
+
+buildGoModule rec {
+  pname = "tscli";
+  version = "0.0.15";
+
+  src = fetchFromGitHub {
+    owner = "jaxxstorm";
+    repo = "tscli";
+    tag = "v${version}";
+    hash = "sha256-RsWpZYRb/6ZpOio5te7qokGJeTlSmu/MH+BVoQVbkNw=";
+  };
+
+  vendorHash = "sha256-RELJJN2ldcUkbyskitg1y6vakdQ6mRkmT7Y25TS2sz8=";
+
+  nativeBuildInputs = [ installShellFiles ];
+
+  ldflags = [
+    "-X=github.com/jaxxstorm/tscli/pkg/version.Version=${version}"
+  ];
+
+  postInstall = lib.optionalString (stdenv.buildPlatform.canExecute stdenv.hostPlatform) ''
+    installShellCompletion --cmd tscli \
+      --bash <($out/bin/tscli -k XXX completion bash) \
+      --fish <($out/bin/tscli -k XXX completion fish) \
+      --zsh <($out/bin/tscli -k XXX completion zsh)
+  '';
+
+  meta = {
+    description = "CLI tool to interact with the Tailscale API";
+    homepage = "https://github.com/jaxxstorm/tscli";
+    changelog = "https://github.com/jaxxstorm/tscli/releases/tag/${src.tag}/CHANGELOG.md";
+    mainProgram = "tscli";
+    license = lib.licenses.mit;
+    maintainers = with lib.maintainers; [ philiptaron ];
+  };
+}

pkgs/by-name/ts/tsduck/package.nix

@@ -0,0 +1,91 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  # build and doc tooling
+  asciidoctor-with-extensions,
+  doxygen,
+  graphviz,
+  python3,
+  ruby,
+  qpdf,
+  udevCheckHook,
+  # build deps
+  curl,
+  glibcLocales,
+  jdk,
+  libedit,
+  librist,
+  openssl,
+  srt,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "tsduck";
+  version = "3.40-4165";
+
+  src = fetchFromGitHub {
+    owner = "tsduck";
+    repo = "tsduck";
+    rev = "v${finalAttrs.version}";
+    sha256 = "sha256-bFnsGoElXeStIX5KwonJuF0x7DDzhzq+3oygkUOmZE0=";
+  };
+
+  nativeBuildInputs = [
+    asciidoctor-with-extensions
+    doxygen
+    graphviz
+    python3
+    ruby
+    qpdf
+    udevCheckHook
+  ];
+
+  buildInputs = [
+    curl
+    glibcLocales
+    jdk
+    libedit
+    librist
+    openssl
+    srt
+  ];
+
+  enableParallelBuilding = true;
+
+  postPatch = ''
+    patchShebangs scripts
+  '';
+
+  # see CONFIG.txt in the sources
+  makeFlags = [
+    "CXXFLAGS_NO_WARNINGS=-Wno-deprecated-declarations"
+    "NODEKTEC=1"
+    "NOGITHUB=1"
+    "NOHIDES=1"
+    "NOPCSC=1"
+    "NOVATEK=1"
+    "SYSPREFIX=/"
+    "SYSROOT=${placeholder "out"}"
+  ];
+
+  # remove tests which break the sandbox
+  patches = [ ./tests.patch ];
+  checkTarget = "test";
+  doCheck = true;
+  doInstallCheck = true;
+
+  installTargets = [
+    "install-tools"
+    "install-devel"
+  ];
+
+  meta = {
+    description = "MPEG Transport Stream Toolkit";
+    homepage = "https://github.com/tsduck/tsduck";
+    mainProgram = "tsversion";
+    license = lib.licenses.bsd2;
+    maintainers = with lib.maintainers; [ siriobalmelli ];
+    platforms = lib.platforms.all;
+  };
+})

pkgs/by-name/ts/tsduck/tests.patch

@@ -0,0 +1,744 @@
+diff --git a/src/utest/utestHLS.cpp b/src/utest/utestHLS.cpp
+index ebfe67f3d..dc023b636 100644
+--- a/src/utest/utestHLS.cpp
++++ b/src/utest/utestHLS.cpp
+@@ -20,9 +20,6 @@
+ 
+ class HLSTest: public tsunit::Test
+ {
+-    TSUNIT_DECLARE_TEST(MasterPlaylist);
+-    TSUNIT_DECLARE_TEST(MasterPlaylistWithAlternate);
+-    TSUNIT_DECLARE_TEST(MediaPlaylist);
+     TSUNIT_DECLARE_TEST(BuildMasterPlaylist);
+     TSUNIT_DECLARE_TEST(BuildMediaPlaylist);
+ 
+@@ -61,176 +58,6 @@ void HLSTest::afterTest()
+ // Unitary tests.
+ //----------------------------------------------------------------------------
+ 
+-TSUNIT_DEFINE_TEST(MasterPlaylist)
+-{
+-    // Test file downloaded from TSDuck web site.
+-    // Copied from Apple test file at
+-    // https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_ts/master.m3u8
+-
+-    ts::hls::PlayList pl;
+-    TSUNIT_ASSERT(pl.loadURL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/master.m3u8", true));
+-    TSUNIT_ASSERT(pl.isValid());
+-    TSUNIT_EQUAL(ts::hls::PlayListType::MASTER, pl.type());
+-    TSUNIT_EQUAL(6, pl.version());
+-    TSUNIT_EQUAL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/master.m3u8", pl.url());
+-    ts::hls::MediaElement media;
+-    pl.buildURL(media, u"foo.bar");
+-    TSUNIT_EQUAL(u"foo.bar", media.relative_uri);
+-    TSUNIT_EQUAL(u"/download/test/hls/img_bipbop_adv_example_ts/foo.bar", media.file_path);
+-    TSUNIT_EQUAL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/foo.bar", media.url.toString());
+-    TSUNIT_EQUAL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/foo.bar", media.urlString());
+-    TSUNIT_EQUAL(0, pl.segmentCount());
+-    TSUNIT_EQUAL(24, pl.playListCount());
+-    TSUNIT_EQUAL(5, pl.altPlayListCount());
+-    TSUNIT_EQUAL(0, pl.targetDuration().count());
+-    TSUNIT_EQUAL(0, pl.mediaSequence());
+-    TSUNIT_ASSERT(!pl.endList());
+-    TSUNIT_EQUAL(ts::hls::PlayListType::MASTER, pl.type());
+-
+-    TSUNIT_EQUAL(u"v5/prog_index.m3u8", pl.playList(0).relative_uri);
+-    TSUNIT_EQUAL(2227464, pl.playList(0).bandwidth.toInt());
+-    TSUNIT_EQUAL(2218327, pl.playList(0).average_bandwidth.toInt());
+-    TSUNIT_EQUAL(960, pl.playList(0).width);
+-    TSUNIT_EQUAL(540, pl.playList(0).height);
+-    TSUNIT_EQUAL(60000, pl.playList(0).frame_rate);
+-    TSUNIT_EQUAL(u"avc1.640020,mp4a.40.2", pl.playList(0).codecs);
+-    TSUNIT_EQUAL(u"", pl.playList(0).hdcp);
+-    TSUNIT_EQUAL(u"", pl.playList(0).video_range);
+-    TSUNIT_EQUAL(u"", pl.playList(0).video);
+-    TSUNIT_EQUAL(u"aud1", pl.playList(0).audio);
+-    TSUNIT_EQUAL(u"sub1", pl.playList(0).subtitles);
+-    TSUNIT_EQUAL(u"cc1", pl.playList(0).closed_captions);
+-    TSUNIT_EQUAL(u"v5/prog_index.m3u8, 960x540, 2,227,464 b/s, @60 fps", pl.playList(0).toString());
+-
+-    TSUNIT_EQUAL(u"v2/prog_index.m3u8", pl.playList(23).relative_uri);
+-    TSUNIT_EQUAL(582387, pl.playList(23).bandwidth.toInt());
+-    TSUNIT_EQUAL(570616, pl.playList(23).average_bandwidth.toInt());
+-    TSUNIT_EQUAL(480, pl.playList(23).width);
+-    TSUNIT_EQUAL(270, pl.playList(23).height);
+-    TSUNIT_EQUAL(30000, pl.playList(23).frame_rate);
+-    TSUNIT_EQUAL(u"avc1.640015,ec-3", pl.playList(23).codecs);
+-    TSUNIT_EQUAL(u"", pl.playList(23).hdcp);
+-    TSUNIT_EQUAL(u"", pl.playList(23).video_range);
+-    TSUNIT_EQUAL(u"", pl.playList(23).video);
+-    TSUNIT_EQUAL(u"aud3", pl.playList(23).audio);
+-    TSUNIT_EQUAL(u"sub1", pl.playList(23).subtitles);
+-    TSUNIT_EQUAL(u"cc1", pl.playList(23).closed_captions);
+-    TSUNIT_EQUAL(u"v2/prog_index.m3u8, 480x270, 582,387 b/s, @30 fps", pl.playList(23).toString());
+-
+-    TSUNIT_EQUAL(0, pl.selectPlayList(0, 0, 0, 0, 0, 0));
+-    TSUNIT_EQUAL(ts::NPOS, pl.selectPlayList(10000000, 0, 0, 0, 0, 0));
+-    TSUNIT_EQUAL(9, pl.selectPlayListHighestBitRate());
+-    TSUNIT_EQUAL(7, pl.selectPlayListLowestBitRate());
+-    TSUNIT_EQUAL(1, pl.selectPlayListHighestResolution());
+-    TSUNIT_EQUAL(7, pl.selectPlayListLowestResolution());
+-}
+-
+-TSUNIT_DEFINE_TEST(MasterPlaylistWithAlternate)
+-{
+-    // Test file downloaded from TSDuck web site.
+-
+-    ts::hls::PlayList pl;
+-    TSUNIT_ASSERT(pl.loadURL(u"https://tsduck.io/download/test/hls/alternative/index_hd.m3u8", true));
+-    TSUNIT_ASSERT(pl.isValid());
+-    TSUNIT_EQUAL(ts::hls::PlayListType::MASTER, pl.type());
+-    TSUNIT_EQUAL(4, pl.version());
+-    TSUNIT_EQUAL(u"https://tsduck.io/download/test/hls/alternative/index_hd.m3u8", pl.url());
+-    TSUNIT_EQUAL(0, pl.segmentCount());
+-    TSUNIT_EQUAL(7, pl.playListCount());
+-    TSUNIT_EQUAL(2, pl.altPlayListCount());
+-    TSUNIT_EQUAL(0, pl.targetDuration().count());
+-    TSUNIT_EQUAL(0, pl.mediaSequence());
+-    TSUNIT_ASSERT(!pl.endList());
+-    TSUNIT_EQUAL(ts::hls::PlayListType::MASTER, pl.type());
+-
+-    TSUNIT_EQUAL(u"04_hd.m3u8", pl.playList(0).relative_uri);
+-    TSUNIT_EQUAL(1209781, pl.playList(0).bandwidth.toInt());
+-    TSUNIT_EQUAL(768, pl.playList(0).width);
+-    TSUNIT_EQUAL(432, pl.playList(0).height);
+-    TSUNIT_EQUAL(25000, pl.playList(0).frame_rate);
+-    TSUNIT_EQUAL(u"avc1.4D4020,mp4a.40.2", pl.playList(0).codecs);
+-    TSUNIT_EQUAL(u"", pl.playList(0).hdcp);
+-    TSUNIT_EQUAL(u"", pl.playList(0).video_range);
+-    TSUNIT_EQUAL(u"", pl.playList(0).video);
+-    TSUNIT_EQUAL(u"audio2", pl.playList(0).audio);
+-    TSUNIT_EQUAL(u"", pl.playList(0).subtitles);
+-    TSUNIT_EQUAL(u"", pl.playList(0).closed_captions);
+-    TSUNIT_EQUAL(u"04_hd.m3u8, 768x432, 1,209,781 b/s, @25 fps", pl.playList(0).toString());
+-
+-    TSUNIT_EQUAL(u"09_hd.m3u8", pl.altPlayList(0).relative_uri);
+-    TSUNIT_EQUAL(u"AUDIO", pl.altPlayList(0).type);
+-    TSUNIT_EQUAL(u"audio2", pl.altPlayList(0).group_id);
+-    TSUNIT_EQUAL(u"ENG", pl.altPlayList(0).name);
+-    TSUNIT_EQUAL(u"ENG", pl.altPlayList(0).language);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(0).stable_rendition_id);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(0).assoc_language);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(0).in_stream_id);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(0).characteristics);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(0).channels);
+-    TSUNIT_ASSERT(pl.altPlayList(0).is_default);
+-    TSUNIT_ASSERT(pl.altPlayList(0).auto_select);
+-    TSUNIT_ASSERT(!pl.altPlayList(0).forced);
+-
+-    TSUNIT_EQUAL(u"01_hd.m3u8", pl.altPlayList(1).relative_uri);
+-    TSUNIT_EQUAL(u"AUDIO", pl.altPlayList(1).type);
+-    TSUNIT_EQUAL(u"audio1", pl.altPlayList(1).group_id);
+-    TSUNIT_EQUAL(u"FOO", pl.altPlayList(1).name);
+-    TSUNIT_EQUAL(u"FOO", pl.altPlayList(1).language);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(1).stable_rendition_id);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(1).assoc_language);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(1).in_stream_id);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(1).characteristics);
+-    TSUNIT_EQUAL(u"", pl.altPlayList(1).channels);
+-    TSUNIT_ASSERT(!pl.altPlayList(1).is_default);
+-    TSUNIT_ASSERT(!pl.altPlayList(1).auto_select);
+-    TSUNIT_ASSERT(!pl.altPlayList(1).forced);
+-}
+-
+-TSUNIT_DEFINE_TEST(MediaPlaylist)
+-{
+-    // Test file downloaded from TSDuck web site.
+-    // Copied from Apple test file at
+-    // https://devstreaming-cdn.apple.com/videos/streaming/examples/img_bipbop_adv_example_ts/v5/prog_index.m3u8
+-
+-    ts::hls::PlayList pl;
+-    TSUNIT_ASSERT(pl.loadURL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/v5/prog_index.m3u8", true));
+-    TSUNIT_ASSERT(pl.isValid());
+-    TSUNIT_EQUAL(ts::hls::PlayListType::VOD, pl.type());
+-    TSUNIT_EQUAL(3, pl.version());
+-    TSUNIT_EQUAL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/v5/prog_index.m3u8", pl.url());
+-    ts::hls::MediaElement media;
+-    pl.buildURL(media, u"foo.bar");
+-    TSUNIT_EQUAL(u"https://tsduck.io/download/test/hls/img_bipbop_adv_example_ts/v5/foo.bar", media.urlString());
+-    TSUNIT_EQUAL(100, pl.segmentCount());
+-    TSUNIT_EQUAL(0, pl.playListCount());
+-    TSUNIT_EQUAL(0, pl.altPlayListCount());
+-    TSUNIT_EQUAL(6, pl.targetDuration().count());
+-    TSUNIT_EQUAL(0, pl.mediaSequence());
+-    TSUNIT_ASSERT(pl.endList());
+-
+-    TSUNIT_EQUAL(u"fileSequence0.ts", pl.segment(0).relative_uri);
+-    TSUNIT_EQUAL(u"", pl.segment(0).title);
+-    TSUNIT_EQUAL(2060 * 1024, pl.segment(0).bitrate.toInt());
+-    TSUNIT_EQUAL(6000, pl.segment(0).duration.count());
+-    TSUNIT_ASSERT(!pl.segment(0).gap);
+-
+-    TSUNIT_EQUAL(u"fileSequence99.ts", pl.segment(99).relative_uri);
+-    TSUNIT_EQUAL(u"", pl.segment(99).title);
+-    TSUNIT_EQUAL(2055 * 1024, pl.segment(99).bitrate.toInt());
+-    TSUNIT_EQUAL(6000, pl.segment(99).duration.count());
+-    TSUNIT_ASSERT(!pl.segment(99).gap);
+-
+-    ts::hls::MediaSegment seg;
+-    TSUNIT_ASSERT(pl.popFirstSegment(seg));
+-    TSUNIT_EQUAL(99, pl.segmentCount());
+-
+-    TSUNIT_EQUAL(u"fileSequence0.ts", seg.relative_uri);
+-    TSUNIT_EQUAL(u"", seg.title);
+-    TSUNIT_EQUAL(2060 * 1024, seg.bitrate.toInt());
+-    TSUNIT_EQUAL(6000, seg.duration.count());
+-    TSUNIT_ASSERT(!seg.gap);
+-}
+-
+ TSUNIT_DEFINE_TEST(BuildMasterPlaylist)
+ {
+     ts::hls::PlayList pl;
+diff --git a/src/utest/utestNetworking.cpp b/src/utest/utestNetworking.cpp
+index 058d5eb4c..67e5610d5 100644
+--- a/src/utest/utestNetworking.cpp
++++ b/src/utest/utestNetworking.cpp
+@@ -33,19 +33,13 @@
+ class NetworkingTest: public tsunit::Test
+ {
+     TSUNIT_DECLARE_TEST(SystemStructures);
+-    TSUNIT_DECLARE_TEST(IPv4AddressConstructors);
+-    TSUNIT_DECLARE_TEST(IPv4Address);
+-    TSUNIT_DECLARE_TEST(IPv6Address);
+     TSUNIT_DECLARE_TEST(Conversion);
+     TSUNIT_DECLARE_TEST(IPAddressMask);
+     TSUNIT_DECLARE_TEST(MACAddress);
+     TSUNIT_DECLARE_TEST(LocalHost);
+     TSUNIT_DECLARE_TEST(GetLocalIPAddresses);
+-    TSUNIT_DECLARE_TEST(IPv4SocketAddressConstructors);
+     TSUNIT_DECLARE_TEST(IPv4SocketAddress);
+     TSUNIT_DECLARE_TEST(IPv6SocketAddress);
+-    TSUNIT_DECLARE_TEST(TCPSocket);
+-    TSUNIT_DECLARE_TEST(UDPSocket);
+     TSUNIT_DECLARE_TEST(IPHeader);
+     TSUNIT_DECLARE_TEST(IPProtocol);
+     TSUNIT_DECLARE_TEST(TCPPacket);
+@@ -96,183 +90,6 @@ TSUNIT_DEFINE_TEST(SystemStructures)
+             << "NetworkingTest::SystemStructures: sizeof(::sockaddr_storage) = " << sizeof(::sockaddr_storage) << std::endl;
+ }
+ 
+-TSUNIT_DEFINE_TEST(IPv4AddressConstructors)
+-{
+-    TSUNIT_ASSERT(ts::IPInitialize());
+-
+-    TSUNIT_EQUAL(0, ts::IPAddress::AnyAddress4.address4());
+-    TSUNIT_EQUAL(0x7F000001, ts::IPAddress::LocalHost4.address4()); // 127.0.0.1
+-
+-    ts::IPAddress a1;
+-    TSUNIT_EQUAL(0, a1.address4());
+-
+-    ts::IPAddress a2(0x01020304);
+-    TSUNIT_EQUAL(0x01020304, a2.address4());
+-
+-    ts::IPAddress a3(1, 2, 3, 4);
+-    TSUNIT_EQUAL(0x01020304, a3.address4());
+-
+-    ::in_addr ia4;
+-    ia4.s_addr = htonl(0x01020304);
+-    ts::IPAddress a4(ia4);
+-    TSUNIT_EQUAL(0x01020304, a4.address4());
+-
+-    ::sockaddr sa5;
+-    TSUNIT_ASSERT(sizeof(::sockaddr) >= sizeof(::sockaddr_in));
+-    ::sockaddr_in* sai5 = reinterpret_cast<::sockaddr_in*>(&sa5);
+-    sai5->sin_family = AF_INET;
+-    sai5->sin_addr.s_addr = htonl(0x01020304);
+-    sai5->sin_port = 0;
+-    ts::IPAddress a5 (sa5);
+-    TSUNIT_EQUAL(0x01020304, a5.address4());
+-
+-    ::sockaddr_in sa6;
+-    sa6.sin_family = AF_INET;
+-    sa6.sin_addr.s_addr = htonl(0x01020304);
+-    sa6.sin_port = 0;
+-    ts::IPAddress a6 (sa6);
+-    TSUNIT_EQUAL(0x01020304, a6.address4());
+-
+-    ts::IPAddress a7(u"2.3.4.5", CERR);
+-    TSUNIT_EQUAL(0x02030405, a7.address4());
+-}
+-
+-TSUNIT_DEFINE_TEST(IPv4Address)
+-{
+-    TSUNIT_ASSERT(ts::IPInitialize());
+-
+-    ts::IPAddress a1 (1, 2, 3, 4);
+-    ts::IPAddress a2 (1, 2, 3, 4);
+-    ts::IPAddress a3 (2, 3, 4, 5);
+-
+-    TSUNIT_EQUAL(u"IPv4", a1.familyName());
+-    TSUNIT_ASSERT(a1 == a2);
+-    TSUNIT_ASSERT(a1 != a3);
+-
+-    a1.setAddress4(0x02030405);
+-    TSUNIT_ASSERT(a1 == a3);
+-
+-    a1.setAddress4(1, 2, 3, 4);
+-    TSUNIT_ASSERT(a1 == a2);
+-
+-    a2.setAddress4(224, 1, 2, 3);
+-    TSUNIT_ASSERT(!a1.isMulticast());
+-    TSUNIT_ASSERT(a2.isMulticast());
+-
+-    TSUNIT_ASSERT(a1.hasAddress());
+-    a1.clear();
+-    TSUNIT_ASSERT(!a1.hasAddress());
+-    TSUNIT_EQUAL(0, a1.address4());
+-
+-    a1.setAddress4(1, 2, 3, 4);
+-    ::in_addr ia;
+-    a1.getAddress4(ia);
+-    TSUNIT_EQUAL(htonl(0x01020304), ia.s_addr);
+-
+-    ::sockaddr_storage sa;
+-    TSUNIT_EQUAL(sizeof(::sockaddr_in), a1.getAddress(sa, 80));
+-    const ::sockaddr_in* saip = reinterpret_cast<const ::sockaddr_in*>(&sa);
+-    TSUNIT_EQUAL(AF_INET, saip->sin_family);
+-    TSUNIT_EQUAL(htonl(0x01020304), saip->sin_addr.s_addr);
+-    TSUNIT_EQUAL(htons(80), saip->sin_port);
+-
+-    ::sockaddr_in sai;
+-    a1.getAddress4(sai, 80);
+-    TSUNIT_EQUAL(AF_INET, sai.sin_family);
+-    TSUNIT_EQUAL(htonl(0x01020304), sai.sin_addr.s_addr);
+-    TSUNIT_EQUAL(htons(80), sai.sin_port);
+-
+-    TSUNIT_ASSERT(a1.resolve(u"2.3.4.5", CERR));
+-    TSUNIT_EQUAL(0x02030405, a1.address4());
+-
+-    a1.setAddress4(2, 3, 4, 5);
+-    const ts::UString s1(a1.toString());
+-    TSUNIT_EQUAL(u"2.3.4.5", s1);
+-
+-    // Note: fail if not connected to a network.
+-    debug() << "NetworkingTest: www.google.com = " << ts::IPAddress(u"www.google.com", CERR) << std::endl;
+-}
+-
+-TSUNIT_DEFINE_TEST(IPv6Address)
+-{
+-    ts::IPAddress a1(ts::IPAddress::AnyAddress6);
+-    TSUNIT_EQUAL(u"IPv6", a1.familyName());
+-    TSUNIT_EQUAL(ts::IP::v6, a1.generation());
+-    TSUNIT_ASSERT(!a1.hasAddress());
+-    TSUNIT_ASSERT(!a1.isMulticast());
+-
+-    TSUNIT_ASSERT(!ts::IPAddress::AnyAddress6.hasAddress());
+-    TSUNIT_ASSERT(ts::IPAddress::LocalHost6.hasAddress());
+-    TSUNIT_EQUAL(0, ts::IPAddress::LocalHost6.networkPrefix6());
+-    TSUNIT_EQUAL(1, ts::IPAddress::LocalHost6.interfaceIdentifier6());
+-
+-    TSUNIT_ASSERT(!a1.resolve(u":", NULLREP));
+-    TSUNIT_ASSERT(!a1.hasAddress());
+-
+-    TSUNIT_ASSERT(a1.resolve(u"::", CERR));
+-    TSUNIT_ASSERT(!a1.hasAddress());
+-    TSUNIT_ASSERT(a1 == ts::IPAddress::AnyAddress6);
+-
+-    TSUNIT_ASSERT(a1.resolve(u"::1", CERR));
+-    TSUNIT_ASSERT(a1.hasAddress());
+-    TSUNIT_ASSERT(a1 == ts::IPAddress::LocalHost6);
+-
+-    TSUNIT_ASSERT(!a1.resolve(u"", NULLREP));
+-    TSUNIT_ASSERT(!a1.hasAddress());
+-
+-    a1.setAddress6(0, 1, 2, 3, 4, 5, 6, 7);
+-    TSUNIT_ASSERT(a1.hasAddress());
+-    TSUNIT_ASSERT(!a1.isIPv4Mapped());
+-    TSUNIT_EQUAL(0x0000000100020003, a1.networkPrefix6());
+-    TSUNIT_EQUAL(0x0004000500060007, a1.interfaceIdentifier6());
+-    TSUNIT_EQUAL(u"0:1:2:3:4:5:6:7", a1.toString());
+-    TSUNIT_EQUAL(u"0000:0001:0002:0003:0004:0005:0006:0007", a1.toFullString());
+-
+-    a1.setAddress6(0x12, 0x345, 0x6789, 0xFFFF, 0, 0, 0, 0xBEEF);
+-    TSUNIT_ASSERT(a1.hasAddress());
+-    TSUNIT_ASSERT(!a1.isIPv4Mapped());
+-    TSUNIT_EQUAL(0x001203456789FFFF, a1.networkPrefix6());
+-    TSUNIT_EQUAL(0x000000000000BEEF, a1.interfaceIdentifier6());
+-    TSUNIT_EQUAL(u"12:345:6789:ffff::beef", a1.toString());
+-    TSUNIT_EQUAL(u"0012:0345:6789:ffff:0000:0000:0000:beef", a1.toFullString());
+-
+-    TSUNIT_ASSERT(a1.resolve(u"fe80::93a3:dea0:2108:b81e", CERR));
+-    TSUNIT_ASSERT(a1.hasAddress());
+-    TSUNIT_ASSERT(!a1.isIPv4Mapped());
+-    TSUNIT_EQUAL(0xFE80000000000000, a1.networkPrefix6());
+-    TSUNIT_EQUAL(0x93A3DEA02108B81E, a1.interfaceIdentifier6());
+-    TSUNIT_EQUAL(u"fe80::93a3:dea0:2108:b81e", a1.toString());
+-    TSUNIT_EQUAL(u"fe80:0000:0000:0000:93a3:dea0:2108:b81e", a1.toFullString());
+-
+-    TSUNIT_ASSERT(a1.convert(ts::IP::Any));
+-    TSUNIT_ASSERT(a1.convert(ts::IP::v6));
+-    TSUNIT_ASSERT(!a1.convert(ts::IP::v4));
+-    TSUNIT_EQUAL(u"IPv6", a1.familyName());
+-    TSUNIT_EQUAL(ts::IP::v6, a1.generation());
+-
+-    ts::IPAddress a2;
+-    TSUNIT_ASSERT(a2.resolve(u"0:0::ffff:12.13.14.15", CERR));
+-    TSUNIT_ASSERT(a2.hasAddress());
+-    TSUNIT_EQUAL(u"IPv6", a2.familyName());
+-    TSUNIT_EQUAL(ts::IP::v6, a2.generation());
+-    TSUNIT_ASSERT(a2.isIPv4Mapped());
+-    TSUNIT_EQUAL(0x0000000000000000, a2.networkPrefix6());
+-    TSUNIT_EQUAL(0x0000FFFF0C0D0E0F, a2.interfaceIdentifier6());
+-    TSUNIT_EQUAL(u"::ffff:12.13.14.15", a2.toString());
+-    TSUNIT_EQUAL(u"0000:0000:0000:0000:0000:ffff:0c0d:0e0f", a2.toFullString());
+-
+-    TSUNIT_ASSERT(a2.convert(ts::IP::Any));
+-    TSUNIT_ASSERT(a2.convert(ts::IP::v6));
+-    TSUNIT_ASSERT(a2.convert(ts::IP::v4));
+-
+-    TSUNIT_ASSERT(a2.hasAddress());
+-    TSUNIT_EQUAL(u"IPv4", a2.familyName());
+-    TSUNIT_EQUAL(ts::IP::v4, a2.generation());
+-    TSUNIT_EQUAL(u"12.13.14.15", a2.toString());
+-    TSUNIT_EQUAL(u"12.13.14.15", a2.toFullString());
+-    TSUNIT_EQUAL(0x0C0D0E0F, a2.address4());
+-}
+-
+ TSUNIT_DEFINE_TEST(Conversion)
+ {
+     ts::IPAddress a1(0x12345678);
+@@ -437,101 +254,6 @@ TSUNIT_DEFINE_TEST(GetLocalIPAddresses)
+     }
+ }
+ 
+-TSUNIT_DEFINE_TEST(IPv4SocketAddressConstructors)
+-{
+-    TSUNIT_ASSERT(ts::IPInitialize());
+-
+-    TSUNIT_EQUAL(0, ts::IPSocketAddress::AnyAddress4.address4());
+-    TSUNIT_EQUAL(0x7F000001, ts::IPSocketAddress::LocalHost4.address4()); // 127.0.0.1
+-
+-    ts::IPSocketAddress a1;
+-    TSUNIT_EQUAL(0, a1.address4());
+-    TSUNIT_EQUAL(0, a1.port());
+-
+-    ts::IPSocketAddress a2a (ts::IPAddress(0x01020304), 80);
+-    TSUNIT_EQUAL(0x01020304, a2a.address4());
+-    TSUNIT_EQUAL(80, a2a.port());
+-
+-    ts::IPSocketAddress a2b(0x01020304, 80);
+-    TSUNIT_EQUAL(0x01020304, a2b.address4());
+-    TSUNIT_EQUAL(80, a2b.port());
+-
+-    ts::IPSocketAddress a3(1, 2, 3, 4, 80);
+-    TSUNIT_EQUAL(0x01020304, a3.address4());
+-    TSUNIT_EQUAL(80, a3.port());
+-
+-    ::in_addr ia4;
+-    ia4.s_addr = htonl(0x01020304);
+-    ts::IPSocketAddress a4(ia4, 80);
+-    TSUNIT_EQUAL(0x01020304, a4.address4());
+-    TSUNIT_EQUAL(80, a4.port());
+-
+-    ::sockaddr sa5;
+-    TSUNIT_ASSERT(sizeof(::sockaddr) >= sizeof(::sockaddr_in));
+-    ::sockaddr_in* sai5 = reinterpret_cast<::sockaddr_in*>(&sa5);
+-    sai5->sin_family = AF_INET;
+-    sai5->sin_addr.s_addr = htonl(0x01020304);
+-    sai5->sin_port = htons (80);
+-    ts::IPSocketAddress a5 (sa5);
+-    TSUNIT_EQUAL(0x01020304, a5.address4());
+-    TSUNIT_EQUAL(80, a5.port());
+-
+-    ::sockaddr_in sa6;
+-    sa6.sin_family = AF_INET;
+-    sa6.sin_addr.s_addr = htonl(0x01020304);
+-    sa6.sin_port = htons(80);
+-    ts::IPSocketAddress a6(sa6);
+-    TSUNIT_EQUAL(0x01020304, a6.address4());
+-    TSUNIT_EQUAL(80, a6.port());
+-
+-    ts::IPSocketAddress a7(u"2.3.4.5", CERR);
+-    TSUNIT_EQUAL(0x02030405, a7.address4());
+-    TSUNIT_EQUAL(ts::IPSocketAddress::AnyPort, a7.port());
+-
+-    // Some hosts can return localhost in IPv4 or IPv6.
+-    ts::IPSocketAddress a8(u"localhost", CERR);
+-    if (a8.generation() == ts::IP::v6) {
+-        TSUNIT_EQUAL(0, a8.hexlet6(0));
+-        TSUNIT_EQUAL(0, a8.hexlet6(1));
+-        TSUNIT_EQUAL(0, a8.hexlet6(2));
+-        TSUNIT_EQUAL(0, a8.hexlet6(3));
+-        TSUNIT_EQUAL(0, a8.hexlet6(4));
+-        TSUNIT_EQUAL(0, a8.hexlet6(5));
+-        TSUNIT_EQUAL(0, a8.hexlet6(8));
+-        TSUNIT_EQUAL(1, a8.hexlet6(7));
+-        TSUNIT_ASSERT(ts::IPAddress(a8) == ts::IPAddress::LocalHost6);
+-    }
+-    else {
+-        TSUNIT_EQUAL(0x7F000001, a8.address4()); // 127.0.0.1
+-        TSUNIT_ASSERT(ts::IPAddress(a8) == ts::IPAddress::LocalHost4);
+-    }
+-    TSUNIT_EQUAL(ts::IPSocketAddress::AnyPort, a8.port());
+-
+-    ts::IPSocketAddress a9(u"2.3.4.5:80", CERR);
+-    TSUNIT_EQUAL(0x02030405, a9.address4());
+-    TSUNIT_EQUAL(80, a9.port());
+-
+-    ts::IPSocketAddress a10(u":80", CERR);
+-    TSUNIT_EQUAL(0, a10.address4());
+-    TSUNIT_EQUAL(80, a10.port());
+-
+-    ts::IPSocketAddress a11(u"83", CERR);
+-    TSUNIT_EQUAL(0, a11.address4());
+-    TSUNIT_EQUAL(83, a11.port());
+-
+-    ts::IPSocketAddress a12(u"2.3.4.5:", CERR);
+-    TSUNIT_EQUAL(0x02030405, a12.address4());
+-    TSUNIT_EQUAL(0, a12.port());
+-
+-    ts::IPSocketAddress a13(u":", CERR);
+-    TSUNIT_EQUAL(0, a13.address4());
+-    TSUNIT_EQUAL(0, a13.port());
+-
+-    ts::IPSocketAddress a14(u"", CERR);
+-    TSUNIT_EQUAL(0, a14.address4());
+-    TSUNIT_EQUAL(0, a14.port());
+-}
+-
+ TSUNIT_DEFINE_TEST(IPv4SocketAddress)
+ {
+     TSUNIT_ASSERT(ts::IPInitialize());
+@@ -739,56 +461,6 @@ namespace {
+     };
+ }
+ 
+-// Test cases
+-TSUNIT_DEFINE_TEST(TCPSocket)
+-{
+-    TSUNIT_ASSERT(ts::IPInitialize());
+-
+-    const uint16_t portNumber = 12345;
+-
+-    // Create server socket
+-    CERR.debug(u"TCPSocketTest: main thread: create server");
+-    const ts::IPSocketAddress serverAddress(ts::IPAddress::LocalHost4, portNumber);
+-    ts::TCPServer server;
+-    TSUNIT_ASSERT(!server.isOpen());
+-    TSUNIT_ASSERT(server.open(ts::IP::v4, CERR));
+-    TSUNIT_ASSERT(server.isOpen());
+-    TSUNIT_ASSERT(server.reusePort(true, CERR));
+-    TSUNIT_ASSERT(server.setSendBufferSize(1024, CERR));
+-    TSUNIT_ASSERT(server.setReceiveBufferSize(1024, CERR));
+-    TSUNIT_ASSERT(server.setTTL(1, CERR));
+-    TSUNIT_ASSERT(server.bind(serverAddress, CERR));
+-    TSUNIT_ASSERT(server.listen(5, CERR));
+-
+-    CERR.debug(u"TCPSocketTest: main thread: starting client thread");
+-    TCPClient client(portNumber);
+-    client.start();
+-
+-    CERR.debug(u"TCPSocketTest: main thread: waiting for a client");
+-    ts::TCPConnection session;
+-    ts::IPSocketAddress clientAddress;
+-    TSUNIT_ASSERT(server.accept(session, clientAddress, CERR));
+-    CERR.debug(u"TCPSocketTest: main thread: got a client");
+-    TSUNIT_ASSERT(ts::IPAddress(clientAddress) == ts::IPAddress::LocalHost4);
+-
+-    CERR.debug(u"TCPSocketTest: main thread: waiting for data");
+-    ts::IPSocketAddress sender;
+-    char buffer [1024];
+-    size_t size = 0;
+-    while (session.receive(buffer, sizeof(buffer), size, nullptr, CERR)) {
+-        CERR.debug(u"TCPSocketTest: main thread: data received, %d bytes", size);
+-        TSUNIT_ASSERT(session.send(buffer, size, CERR));
+-        CERR.debug(u"TCPSocketTest: main thread: data sent back");
+-    }
+-
+-    CERR.debug(u"TCPSocketTest: main thread: end of client session");
+-    session.disconnect(CERR);
+-    session.close(CERR);
+-    TSUNIT_ASSERT(server.close(CERR));
+-
+-    CERR.debug(u"TCPSocketTest: main thread: terminated");
+-}
+-
+ // A thread class which sends one UDP message and wait from the same message to be replied.
+ namespace {
+     class UDPClient: public utest::TSUnitThread
+@@ -848,41 +520,6 @@ namespace {
+     };
+ }
+ 
+-// Test cases
+-TSUNIT_DEFINE_TEST(UDPSocket)
+-{
+-    TSUNIT_ASSERT(ts::IPInitialize());
+-
+-    const uint16_t portNumber = 12345;
+-
+-    // Create server socket
+-    ts::UDPSocket sock;
+-    TSUNIT_ASSERT(!sock.isOpen());
+-    TSUNIT_ASSERT(sock.open(ts::IP::v4, CERR));
+-    TSUNIT_ASSERT(sock.isOpen());
+-    TSUNIT_ASSERT(sock.setSendBufferSize(1024, CERR));
+-    TSUNIT_ASSERT(sock.setReceiveBufferSize(1024, CERR));
+-    TSUNIT_ASSERT(sock.reusePort(true, CERR));
+-    TSUNIT_ASSERT(sock.setTTL(1, false, CERR));
+-    TSUNIT_ASSERT(sock.bind(ts::IPSocketAddress(ts::IPAddress::LocalHost4, portNumber), CERR));
+-
+-    CERR.debug(u"UDPSocketTest: main thread: starting client thread");
+-    UDPClient client(portNumber);
+-    client.start();
+-
+-    CERR.debug(u"UDPSocketTest: main thread: waiting for message");
+-    ts::IPSocketAddress sender;
+-    ts::IPSocketAddress destination;
+-    char buffer [1024];
+-    size_t size;
+-    TSUNIT_ASSERT(sock.receive(buffer, sizeof(buffer), size, sender, destination, nullptr, CERR));
+-    CERR.debug(u"UDPSocketTest: main thread: request received, %d bytes, sender: %s, destination: %s", size, sender, destination);
+-    TSUNIT_ASSERT(ts::IPAddress(sender) == ts::IPAddress::LocalHost4);
+-
+-    TSUNIT_ASSERT(sock.send(buffer, size, sender, CERR));
+-    CERR.debug(u"UDPSocketTest: main thread: reply sent");
+-}
+-
+ TSUNIT_DEFINE_TEST(IPHeader)
+ {
+     static const uint8_t reference_header[] = {
+diff --git a/src/utest/utestSysUtils.cpp b/src/utest/utestSysUtils.cpp
+index e3434d45b..a609e05c7 100644
+--- a/src/utest/utestSysUtils.cpp
++++ b/src/utest/utestSysUtils.cpp
+@@ -48,7 +48,6 @@ class SysUtilsTest: public tsunit::Test
+     TSUNIT_DECLARE_TEST(FileTime);
+     TSUNIT_DECLARE_TEST(Wildcard);
+     TSUNIT_DECLARE_TEST(SearchWildcard);
+-    TSUNIT_DECLARE_TEST(HomeDirectory);
+     TSUNIT_DECLARE_TEST(ProcessCpuTime);
+     TSUNIT_DECLARE_TEST(ProcessVirtualSize);
+     TSUNIT_DECLARE_TEST(IsTerminal);
+@@ -567,16 +566,6 @@ TSUNIT_DEFINE_TEST(SearchWildcard)
+ #endif
+ }
+ 
+-TSUNIT_DEFINE_TEST(HomeDirectory)
+-{
+-    const ts::UString dir(ts::UserHomeDirectory());
+-    debug() << "SysUtilsTest: UserHomeDirectory() = \"" << dir << "\"" << std::endl;
+-
+-    TSUNIT_ASSERT(!dir.empty());
+-    TSUNIT_ASSERT(fs::exists(dir));
+-    TSUNIT_ASSERT(fs::is_directory(dir));
+-}
+-
+ TSUNIT_DEFINE_TEST(ProcessCpuTime)
+ {
+     const cn::milliseconds t1 = ts::GetProcessCpuTime();
+diff --git a/src/utest/utestSystemRandomGenerator.cpp b/src/utest/utestSystemRandomGenerator.cpp
+index 0d7ff13dd..7e9d5b6ef 100644
+--- a/src/utest/utestSystemRandomGenerator.cpp
++++ b/src/utest/utestSystemRandomGenerator.cpp
+@@ -23,7 +23,6 @@
+ class SystemRandomGeneratorTest: public tsunit::Test
+ {
+     TSUNIT_DECLARE_TEST(SystemRandomGenerator);
+-    TSUNIT_DECLARE_TEST(BetterSystemRandomGenerator);
+     TSUNIT_DECLARE_TEST(Range);
+ 
+ private:
+@@ -87,11 +86,6 @@ TSUNIT_DEFINE_TEST(SystemRandomGenerator)
+     testRandom(gen);
+ }
+ 
+-TSUNIT_DEFINE_TEST(BetterSystemRandomGenerator)
+-{
+-    testRandom(ts::BetterSystemRandomGenerator::Instance());
+-}
+-
+ void SystemRandomGeneratorTest::testRandomRange(ts::RandomGenerator& prng, int64_t min, int64_t max)
+ {
+     TSUNIT_ASSERT(prng.ready());
+diff --git a/src/utest/utestWebRequest.cpp b/src/utest/utestWebRequest.cpp
+index d496c8eca..a691910ca 100644
+--- a/src/utest/utestWebRequest.cpp
++++ b/src/utest/utestWebRequest.cpp
+@@ -28,10 +28,6 @@
+ 
+ class WebRequestTest: public tsunit::Test
+ {
+-    TSUNIT_DECLARE_TEST(GitHub);
+-    TSUNIT_DECLARE_TEST(Google);
+-    TSUNIT_DECLARE_TEST(ReadMeFile);
+-    TSUNIT_DECLARE_TEST(NoRedirection);
+     TSUNIT_DECLARE_TEST(NonExistentHost);
+     TSUNIT_DECLARE_TEST(InvalidURL);
+ 
+@@ -89,7 +85,6 @@ void WebRequestTest::testURL(const ts::UString& url, bool expectRedirection, boo
+ 
+     // Test binary download
+     ts::ByteBlock data;
+-    TSUNIT_ASSERT(request.downloadBinaryContent(url, data));
+ 
+     debug() << "WebRequestTest::testURL:" << std::endl
+             << "    Original URL: " << request.originalURL() << std::endl
+@@ -155,59 +150,12 @@ void WebRequestTest::testURL(const ts::UString& url, bool expectRedirection, boo
+ // Test cases
+ //----------------------------------------------------------------------------
+ 
+-TSUNIT_DEFINE_TEST(GitHub)
+-{
+-    testURL(u"http://www.github.com/",
+-            true,     // expectRedirection
+-            true,     // expectSSL
+-            true,     // expectTextContent
+-            false);   // expectInvariant
+-}
+-
+-TSUNIT_DEFINE_TEST(Google)
+-{
+-    testURL(u"http://www.google.com/",
+-            false,    // expectRedirection
+-            false,    // expectSSL
+-            true,     // expectTextContent
+-            false);   // expectInvariant
+-}
+-
+-TSUNIT_DEFINE_TEST(ReadMeFile)
+-{
+-    testURL(u"https://raw.githubusercontent.com/tsduck/tsduck/master/README.md",
+-            false,    // expectRedirection
+-            true,     // expectSSL
+-            true,     // expectTextContent
+-            true);    // expectInvariant
+-}
+-
+-TSUNIT_DEFINE_TEST(NoRedirection)
+-{
+-    ts::WebRequest request(report());
+-    request.setAutoRedirect(false);
+-
+-    ts::ByteBlock data;
+-    TSUNIT_ASSERT(request.downloadBinaryContent(u"http://www.github.com/", data));
+-
+-    debug() << "WebRequestTest::testNoRedirection:" << std::endl
+-            << "    Original URL: " << request.originalURL() << std::endl
+-            << "    Final URL: " << request.finalURL() << std::endl
+-            << "    HTTP status: " << request.httpStatus() << std::endl
+-            << "    Content size: " << request.contentSize() << std::endl;
+-
+-    TSUNIT_EQUAL(3, request.httpStatus() / 100);
+-    TSUNIT_ASSERT(!request.finalURL().empty());
+-    TSUNIT_ASSERT(request.finalURL() != request.originalURL());
+-}
+-
+ TSUNIT_DEFINE_TEST(NonExistentHost)
+ {
+     ts::ReportBuffer<ts::ThreadSafety::None> rep;
+     ts::WebRequest request(rep);
+ 
+     ts::ByteBlock data;
+-    TSUNIT_ASSERT(!request.downloadBinaryContent(u"http://non.existent.fake-domain/", data));
+ 
+     debug() << "WebRequestTest::testNonExistentHost: " << rep.messages() << std::endl;
+ }
+@@ -218,7 +166,6 @@ TSUNIT_DEFINE_TEST(InvalidURL)
+     ts::WebRequest request(rep);
+ 
+     ts::ByteBlock data;
+-    TSUNIT_ASSERT(!request.downloadBinaryContent(u"pouette://tagada/tsoin/tsoin", data));
+ 
+     debug() << "WebRequestTest::testInvalidURL: " << rep.messages() << std::endl;
+ }

pkgs/by-name/ts/tshock/deps.json

@@ -0,0 +1,647 @@
+[
+  {
+    "pname": "BCrypt.Net-Next",
+    "version": "4.0.3",
+    "hash": "sha256-BxXHAjIV2xBuRPUezzC+5jhaHiQhgnqTk1k1ko3D6Ds="
+  },
+  {
+    "pname": "BouncyCastle.Cryptography",
+    "version": "2.2.1",
+    "hash": "sha256-KDNexXG10Ub5G0M5BOvaFDByGPiSo0HG8GJWWB473Y0="
+  },
+  {
+    "pname": "GetText.NET",
+    "version": "1.7.14",
+    "hash": "sha256-IR27r7SZJFomN/bu4hO5SeQNGr67DQREIKdjsV7RICc="
+  },
+  {
+    "pname": "Google.Protobuf",
+    "version": "3.25.1",
+    "hash": "sha256-UfP/iIcARptUcTVptj/5JQ9Jz9AG3aj+iKotsetOnH0="
+  },
+  {
+    "pname": "K4os.Compression.LZ4",
+    "version": "1.3.5",
+    "hash": "sha256-M0FaJTS3XRBp5tV02BhrrOLVyzP39cQnpEVY8KGNads="
+  },
+  {
+    "pname": "K4os.Compression.LZ4.Streams",
+    "version": "1.3.5",
+    "hash": "sha256-BhR48hN/7z2NVgMw1MRnilpjAUNMZ0LDDhmVYnCXoCY="
+  },
+  {
+    "pname": "K4os.Hash.xxHash",
+    "version": "1.0.8",
+    "hash": "sha256-ILTWT8NFB7itGpDloJh65B5ZuWHrN2dOUQdm8gNy4W8="
+  },
+  {
+    "pname": "Microsoft.Data.Sqlite",
+    "version": "6.0.11",
+    "hash": "sha256-K+2ZSdaQ9XrAglqxjlIkwBj4NlHhV7FvHTfNCM11u7k="
+  },
+  {
+    "pname": "Microsoft.Data.Sqlite.Core",
+    "version": "6.0.11",
+    "hash": "sha256-ndL66WlBdAOU6V8k23d/T11r0s8gnBqbGWRZF9Bc7AU="
+  },
+  {
+    "pname": "Microsoft.NETCore.Platforms",
+    "version": "1.1.0",
+    "hash": "sha256-FeM40ktcObQJk4nMYShB61H/E8B7tIKfl9ObJ0IOcCM="
+  },
+  {
+    "pname": "Microsoft.NETCore.Platforms",
+    "version": "2.0.0",
+    "hash": "sha256-IEvBk6wUXSdyCnkj6tHahOJv290tVVT8tyemYcR0Yro="
+  },
+  {
+    "pname": "Microsoft.NETCore.Platforms",
+    "version": "3.1.0",
+    "hash": "sha256-cnygditsEaU86bnYtIthNMymAHqaT/sf9Gjykhzqgb0="
+  },
+  {
+    "pname": "Microsoft.NETCore.Targets",
+    "version": "1.1.0",
+    "hash": "sha256-0AqQ2gMS8iNlYkrD+BxtIg7cXMnr9xZHtKAuN4bjfaQ="
+  },
+  {
+    "pname": "Microsoft.Win32.SystemEvents",
+    "version": "4.7.0",
+    "hash": "sha256-GHxnD1Plb32GJWVWSv0Y51Kgtlb+cdKgOYVBYZSgVF4="
+  },
+  {
+    "pname": "Microsoft.Win32.SystemEvents",
+    "version": "6.0.0",
+    "hash": "sha256-N9EVZbl5w1VnMywGXyaVWzT9lh84iaJ3aD48hIBk1zA="
+  },
+  {
+    "pname": "ModFramework",
+    "version": "1.1.7",
+    "hash": "sha256-fKP5njd+98RYQ/1tqaT0vyIalZbcSUQdo50ucQ7F1hk="
+  },
+  {
+    "pname": "Mono.Cecil",
+    "version": "0.11.4",
+    "hash": "sha256-HrnRgFsOzfqAWw0fUxi/vkzZd8dMn5zueUeLQWA9qvs="
+  },
+  {
+    "pname": "MonoMod",
+    "version": "22.5.1.1",
+    "hash": "sha256-VB1xZV+MLAzB/e6uTKW2/IEy9Qzo6vzsxg5ot1bWiPs="
+  },
+  {
+    "pname": "MonoMod.RuntimeDetour",
+    "version": "22.5.1.1",
+    "hash": "sha256-ivxQJ6VWxzapaxkDvkRZvDQVgpfmFP1afRlx6yolBXM="
+  },
+  {
+    "pname": "MonoMod.RuntimeDetour.HookGen",
+    "version": "22.5.1.1",
+    "hash": "sha256-jKPij21zrysQO8MnzECpJKVAqil5ZdODyGZOx7j0dRg="
+  },
+  {
+    "pname": "MonoMod.Utils",
+    "version": "22.5.1.1",
+    "hash": "sha256-5m6C8anC0Z4Ihaxg6PTmXU7UOGiyzV+byZDO8+w/kl8="
+  },
+  {
+    "pname": "MySql.Data",
+    "version": "8.4.0",
+    "hash": "sha256-fbNsIdRJVbD7NfAKhDJWDq5m5vXcRGzl9DBzQytM4cA="
+  },
+  {
+    "pname": "Newtonsoft.Json",
+    "version": "13.0.1",
+    "hash": "sha256-K2tSVW4n4beRPzPu3rlVaBEMdGvWSv/3Q1fxaDh4Mjo="
+  },
+  {
+    "pname": "NuGet.Common",
+    "version": "6.3.1",
+    "hash": "sha256-N6NMNL4d2IQsa/AEjyBesbStXTtR8kaL2e7aW7BdBvs="
+  },
+  {
+    "pname": "NuGet.Common",
+    "version": "6.3.4",
+    "hash": "sha256-GDzEyx9/wdVOUAri94uoDjChmfDnBhI90nBfzoHarts="
+  },
+  {
+    "pname": "NuGet.Configuration",
+    "version": "6.3.1",
+    "hash": "sha256-Ha04pwa124ptbBH/PBn45dBGpDIPKcMDd+Fil91g728="
+  },
+  {
+    "pname": "NuGet.Configuration",
+    "version": "6.3.4",
+    "hash": "sha256-qXIONIKcCIXJUmNJQs7MINQ18qIEUByTtW5xsORoZoc="
+  },
+  {
+    "pname": "NuGet.Frameworks",
+    "version": "6.3.1",
+    "hash": "sha256-FAzvIULDH4/MnutbHL3NUZwpzcBAu0qgSKitFSTlbJY="
+  },
+  {
+    "pname": "NuGet.Frameworks",
+    "version": "6.3.4",
+    "hash": "sha256-zqogus3HXQYSiqfnhVH2jd2VZXa+uTsmaw/uwD8dlgY="
+  },
+  {
+    "pname": "NuGet.Packaging",
+    "version": "6.3.1",
+    "hash": "sha256-YiHpqIbOmfYMtJKACeL2nJ5oRngHTPcLN8e4+6IBggs="
+  },
+  {
+    "pname": "NuGet.Packaging",
+    "version": "6.3.4",
+    "hash": "sha256-1LKM5vgfNKn8v2LcqialwmcynACISR57q13n7I2lQbU="
+  },
+  {
+    "pname": "NuGet.Protocol",
+    "version": "6.3.1",
+    "hash": "sha256-9dYUTW/oor665WSDG6mu7HILPVzdO2/2pgiEPb5NMF0="
+  },
+  {
+    "pname": "NuGet.Protocol",
+    "version": "6.3.3",
+    "hash": "sha256-xRW7RMwHqSvTUhSaSI5s2OTSUtcLvvi4dy3ncXIb9I4="
+  },
+  {
+    "pname": "NuGet.Resolver",
+    "version": "6.3.1",
+    "hash": "sha256-NAvCKWepFnswh5Q8ecGXhfki7i2lDahDCit9v706mrE="
+  },
+  {
+    "pname": "NuGet.Versioning",
+    "version": "6.3.1",
+    "hash": "sha256-wNM/C2Y+K+gjceaXD2nHuBkZZgshBMo9NQ9h9gz/RnQ="
+  },
+  {
+    "pname": "NuGet.Versioning",
+    "version": "6.3.4",
+    "hash": "sha256-6CMYVQeGfXu+xner3T3mgl/iQfXiYixoHizmrNA6bvQ="
+  },
+  {
+    "pname": "OTAPI.Upcoming",
+    "version": "3.1.20",
+    "hash": "sha256-ONMBrJG5hDmdkRQhyF0tHxd5M/NebsOkhQmnyfKVK0Y="
+  },
+  {
+    "pname": "runtime.any.System.Collections",
+    "version": "4.3.0",
+    "hash": "sha256-4PGZqyWhZ6/HCTF2KddDsbmTTjxs2oW79YfkberDZS8="
+  },
+  {
+    "pname": "runtime.any.System.Globalization",
+    "version": "4.3.0",
+    "hash": "sha256-PaiITTFI2FfPylTEk7DwzfKeiA/g/aooSU1pDcdwWLU="
+  },
+  {
+    "pname": "runtime.any.System.IO",
+    "version": "4.3.0",
+    "hash": "sha256-vej7ySRhyvM3pYh/ITMdC25ivSd0WLZAaIQbYj/6HVE="
+  },
+  {
+    "pname": "runtime.any.System.Reflection",
+    "version": "4.3.0",
+    "hash": "sha256-ns6f++lSA+bi1xXgmW1JkWFb2NaMD+w+YNTfMvyAiQk="
+  },
+  {
+    "pname": "runtime.any.System.Reflection.Extensions",
+    "version": "4.3.0",
+    "hash": "sha256-Y2AnhOcJwJVYv7Rp6Jz6ma0fpITFqJW+8rsw106K2X8="
+  },
+  {
+    "pname": "runtime.any.System.Reflection.Primitives",
+    "version": "4.3.0",
+    "hash": "sha256-LkPXtiDQM3BcdYkAm5uSNOiz3uF4J45qpxn5aBiqNXQ="
+  },
+  {
+    "pname": "runtime.any.System.Resources.ResourceManager",
+    "version": "4.3.0",
+    "hash": "sha256-9EvnmZslLgLLhJ00o5MWaPuJQlbUFcUF8itGQNVkcQ4="
+  },
+  {
+    "pname": "runtime.any.System.Runtime",
+    "version": "4.3.0",
+    "hash": "sha256-qwhNXBaJ1DtDkuRacgHwnZmOZ1u9q7N8j0cWOLYOELM="
+  },
+  {
+    "pname": "runtime.any.System.Runtime.Handles",
+    "version": "4.3.0",
+    "hash": "sha256-PQRACwnSUuxgVySO1840KvqCC9F8iI9iTzxNW0RcBS4="
+  },
+  {
+    "pname": "runtime.any.System.Runtime.InteropServices",
+    "version": "4.3.0",
+    "hash": "sha256-Kaw5PnLYIiqWbsoF3VKJhy7pkpoGsUwn4ZDCKscbbzA="
+  },
+  {
+    "pname": "runtime.any.System.Text.Encoding",
+    "version": "4.3.0",
+    "hash": "sha256-Q18B9q26MkWZx68exUfQT30+0PGmpFlDgaF0TnaIGCs="
+  },
+  {
+    "pname": "runtime.any.System.Threading.Tasks",
+    "version": "4.3.0",
+    "hash": "sha256-agdOM0NXupfHbKAQzQT8XgbI9B8hVEh+a/2vqeHctg4="
+  },
+  {
+    "pname": "runtime.debian.8-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-LXUPLX3DJxsU1Pd3UwjO1PO9NM2elNEDXeu2Mu/vNps="
+  },
+  {
+    "pname": "runtime.fedora.23-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-qeSqaUI80+lqw5MK4vMpmO0CZaqrmYktwp6L+vQAb0I="
+  },
+  {
+    "pname": "runtime.fedora.24-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-SrHqT9wrCBsxILWtaJgGKd6Odmxm8/Mh7Kh0CUkZVzA="
+  },
+  {
+    "pname": "runtime.native.System",
+    "version": "4.3.0",
+    "hash": "sha256-ZBZaodnjvLXATWpXXakFgcy6P+gjhshFXmglrL5xD5Y="
+  },
+  {
+    "pname": "runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-Jy01KhtcCl2wjMpZWH+X3fhHcVn+SyllWFY8zWlz/6I="
+  },
+  {
+    "pname": "runtime.opensuse.13.2-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-wyv00gdlqf8ckxEdV7E+Ql9hJIoPcmYEuyeWb5Oz3mM="
+  },
+  {
+    "pname": "runtime.opensuse.42.1-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-zi+b4sCFrA9QBiSGDD7xPV27r3iHGlV99gpyVUjRmc4="
+  },
+  {
+    "pname": "runtime.osx.10.10-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-gybQU6mPgaWV3rBG2dbH6tT3tBq8mgze3PROdsuWnX0="
+  },
+  {
+    "pname": "runtime.rhel.7-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-VsP72GVveWnGUvS/vjOQLv1U80H2K8nZ4fDAmI61Hm4="
+  },
+  {
+    "pname": "runtime.ubuntu.14.04-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-4yKGa/IrNCKuQ3zaDzILdNPD32bNdy6xr5gdJigyF5g="
+  },
+  {
+    "pname": "runtime.ubuntu.16.04-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-HmdJhhRsiVoOOCcUvAwdjpMRiyuSwdcgEv2j9hxi+Zc="
+  },
+  {
+    "pname": "runtime.ubuntu.16.10-x64.runtime.native.System.Security.Cryptography.OpenSsl",
+    "version": "4.3.0",
+    "hash": "sha256-pVFUKuPPIx0edQKjzRon3zKq8zhzHEzko/lc01V/jdw="
+  },
+  {
+    "pname": "runtime.unix.System.Diagnostics.Debug",
+    "version": "4.3.0",
+    "hash": "sha256-ReoazscfbGH+R6s6jkg5sIEHWNEvjEoHtIsMbpc7+tI="
+  },
+  {
+    "pname": "runtime.unix.System.Private.Uri",
+    "version": "4.3.0",
+    "hash": "sha256-c5tXWhE/fYbJVl9rXs0uHh3pTsg44YD1dJvyOA0WoMs="
+  },
+  {
+    "pname": "runtime.unix.System.Runtime.Extensions",
+    "version": "4.3.0",
+    "hash": "sha256-l8S9gt6dk3qYG6HYonHtdlYtBKyPb29uQ6NDjmrt3V4="
+  },
+  {
+    "pname": "SharpZipLib",
+    "version": "1.4.2",
+    "hash": "sha256-/giVqikworG2XKqfN9uLyjUSXr35zBuZ2FX2r8X/WUY="
+  },
+  {
+    "pname": "SQLitePCLRaw.bundle_e_sqlite3",
+    "version": "2.0.6",
+    "hash": "sha256-o6uXTtcxjb7H33I8UL4XLgx9y/f/iNeXx6z0NopR4MY="
+  },
+  {
+    "pname": "SQLitePCLRaw.core",
+    "version": "2.0.6",
+    "hash": "sha256-MXi9UEga37dJyFuMg0AVt8enKdr54KlOFT/ssMHzkfA="
+  },
+  {
+    "pname": "SQLitePCLRaw.lib.e_sqlite3",
+    "version": "2.0.6",
+    "hash": "sha256-o68At523MDwLEuRxjM+4EiydK4ITSFyc9R0zGmBGZ5g="
+  },
+  {
+    "pname": "SQLitePCLRaw.provider.e_sqlite3",
+    "version": "2.0.6",
+    "hash": "sha256-308v2h3rvcPSsR9F+yFdJC1QEHgOQtuVxTMs5j3ODzI="
+  },
+  {
+    "pname": "Steamworks.NET",
+    "version": "20.1.0",
+    "hash": "sha256-vt1UVbH4mHGPm7hTW2wKRrSzaFaHz9ZSuiaYeOhs6Ws="
+  },
+  {
+    "pname": "System.Buffers",
+    "version": "4.5.1",
+    "hash": "sha256-wws90sfi9M7kuCPWkv1CEYMJtCqx9QB/kj0ymlsNaxI="
+  },
+  {
+    "pname": "System.Collections",
+    "version": "4.3.0",
+    "hash": "sha256-afY7VUtD6w/5mYqrce8kQrvDIfS2GXDINDh73IjxJKc="
+  },
+  {
+    "pname": "System.Collections.Immutable",
+    "version": "6.0.0",
+    "hash": "sha256-DKEbpFqXCIEfqp9p3ezqadn5b/S1YTk32/EQK+tEScs="
+  },
+  {
+    "pname": "System.Collections.NonGeneric",
+    "version": "4.3.0",
+    "hash": "sha256-8/yZmD4jjvq7m68SPkJZLBQ79jOTOyT5lyzX4SCYAx8="
+  },
+  {
+    "pname": "System.Collections.Specialized",
+    "version": "4.3.0",
+    "hash": "sha256-QNg0JJNx+zXMQ26MJRPzH7THdtqjrNtGLUgaR1SdvOk="
+  },
+  {
+    "pname": "System.CommandLine",
+    "version": "2.0.0-beta4.22272.1",
+    "hash": "sha256-zSO+CYnMH8deBHDI9DHhCPj79Ce3GOzHCyH1/TiHxcc="
+  },
+  {
+    "pname": "System.ComponentModel",
+    "version": "4.3.0",
+    "hash": "sha256-i00uujMO4JEDIEPKLmdLY3QJ6vdSpw6Gh9oOzkFYBiU="
+  },
+  {
+    "pname": "System.ComponentModel.Primitives",
+    "version": "4.3.0",
+    "hash": "sha256-IOMJleuIBppmP4ECB3uftbdcgL7CCd56+oAD/Sqrbus="
+  },
+  {
+    "pname": "System.ComponentModel.TypeConverter",
+    "version": "4.3.0",
+    "hash": "sha256-PSDiPYt8PgTdTUBz+GH6lHCaM1YgfObneHnZsc8Fz54="
+  },
+  {
+    "pname": "System.Configuration.ConfigurationManager",
+    "version": "4.4.1",
+    "hash": "sha256-4i8PUO1XTLfdUzeFxfHtR6xOP7mM3DD+ST9FviQl7zc="
+  },
+  {
+    "pname": "System.Configuration.ConfigurationManager",
+    "version": "6.0.0",
+    "hash": "sha256-fPV668Cfi+8pNWrvGAarF4fewdPVEDwlJWvJk0y+Cms="
+  },
+  {
+    "pname": "System.Diagnostics.Debug",
+    "version": "4.3.0",
+    "hash": "sha256-fkA79SjPbSeiEcrbbUsb70u9B7wqbsdM9s1LnoKj0gM="
+  },
+  {
+    "pname": "System.Diagnostics.DiagnosticSource",
+    "version": "7.0.2",
+    "hash": "sha256-8Uawe7mWOQsDzMSAAP16nuGD1FRSajyS8q+cA++MJ8E="
+  },
+  {
+    "pname": "System.Diagnostics.PerformanceCounter",
+    "version": "6.0.1",
+    "hash": "sha256-53t07yyRBb6sC4e3IjTp5fj44+p6JpX2zpr5/Bbf5Z4="
+  },
+  {
+    "pname": "System.Drawing.Common",
+    "version": "4.7.0",
+    "hash": "sha256-D3qG+xAe78lZHvlco9gHK2TEAM370k09c6+SQi873Hk="
+  },
+  {
+    "pname": "System.Drawing.Common",
+    "version": "6.0.0",
+    "hash": "sha256-/9EaAbEeOjELRSMZaImS1O8FmUe8j4WuFUw1VOrPyAo="
+  },
+  {
+    "pname": "System.Formats.Asn1",
+    "version": "5.0.0",
+    "hash": "sha256-9nL3dN4w/dZ49W1pCkTjRqZm6Dh0mMVExNungcBHrKs="
+  },
+  {
+    "pname": "System.Globalization",
+    "version": "4.3.0",
+    "hash": "sha256-caL0pRmFSEsaoeZeWN5BTQtGrAtaQPwFi8YOZPZG5rI="
+  },
+  {
+    "pname": "System.Globalization.Extensions",
+    "version": "4.3.0",
+    "hash": "sha256-mmJWA27T0GRVuFP9/sj+4TrR4GJWrzNIk2PDrbr7RQk="
+  },
+  {
+    "pname": "System.IO",
+    "version": "4.3.0",
+    "hash": "sha256-ruynQHekFP5wPrDiVyhNiRIXeZ/I9NpjK5pU+HPDiRY="
+  },
+  {
+    "pname": "System.IO.FileSystem.Primitives",
+    "version": "4.3.0",
+    "hash": "sha256-LMnfg8Vwavs9cMnq9nNH8IWtAtSfk0/Fy4s4Rt9r1kg="
+  },
+  {
+    "pname": "System.IO.Pipelines",
+    "version": "6.0.3",
+    "hash": "sha256-v+FOmjRRKlDtDW6+TfmyMiiki010YGVTa0EwXu9X7ck="
+  },
+  {
+    "pname": "System.Linq",
+    "version": "4.3.0",
+    "hash": "sha256-R5uiSL3l6a3XrXSSL6jz+q/PcyVQzEAByiuXZNSqD/A="
+  },
+  {
+    "pname": "System.Memory",
+    "version": "4.5.3",
+    "hash": "sha256-Cvl7RbRbRu9qKzeRBWjavUkseT2jhZBUWV1SPipUWFk="
+  },
+  {
+    "pname": "System.Private.Uri",
+    "version": "4.3.0",
+    "hash": "sha256-fVfgcoP4AVN1E5wHZbKBIOPYZ/xBeSIdsNF+bdukIRM="
+  },
+  {
+    "pname": "System.Reflection",
+    "version": "4.3.0",
+    "hash": "sha256-NQSZRpZLvtPWDlvmMIdGxcVuyUnw92ZURo0hXsEshXY="
+  },
+  {
+    "pname": "System.Reflection.Emit.ILGeneration",
+    "version": "4.7.0",
+    "hash": "sha256-GUnQeGo/DtvZVQpFnESGq7lJcjB30/KnDY7Kd2G/ElE="
+  },
+  {
+    "pname": "System.Reflection.Emit.Lightweight",
+    "version": "4.7.0",
+    "hash": "sha256-V0Wz/UUoNIHdTGS9e1TR89u58zJjo/wPUWw6VaVyclU="
+  },
+  {
+    "pname": "System.Reflection.Extensions",
+    "version": "4.3.0",
+    "hash": "sha256-mMOCYzUenjd4rWIfq7zIX9PFYk/daUyF0A8l1hbydAk="
+  },
+  {
+    "pname": "System.Reflection.Metadata",
+    "version": "6.0.0",
+    "hash": "sha256-VJHXPjP05w6RE/Swu8wa2hilEWuji3g9bl/6lBMSC/Q="
+  },
+  {
+    "pname": "System.Reflection.MetadataLoadContext",
+    "version": "6.0.0",
+    "hash": "sha256-82aeU8c4rnYPLL3ba1ho1fxfpYQt5qrSK5e6ES+OTsY="
+  },
+  {
+    "pname": "System.Reflection.Primitives",
+    "version": "4.3.0",
+    "hash": "sha256-5ogwWB4vlQTl3jjk1xjniG2ozbFIjZTL9ug0usZQuBM="
+  },
+  {
+    "pname": "System.Reflection.TypeExtensions",
+    "version": "4.7.0",
+    "hash": "sha256-GEtCGXwtOnkYejSV+Tfl+DqyGq5jTUaVyL9eMupMHBM="
+  },
+  {
+    "pname": "System.Resources.ResourceManager",
+    "version": "4.3.0",
+    "hash": "sha256-idiOD93xbbrbwwSnD4mORA9RYi/D/U48eRUsn/WnWGo="
+  },
+  {
+    "pname": "System.Runtime",
+    "version": "4.3.0",
+    "hash": "sha256-51813WXpBIsuA6fUtE5XaRQjcWdQ2/lmEokJt97u0Rg="
+  },
+  {
+    "pname": "System.Runtime.CompilerServices.Unsafe",
+    "version": "6.0.0",
+    "hash": "sha256-bEG1PnDp7uKYz/OgLOWs3RWwQSVYm+AnPwVmAmcgp2I="
+  },
+  {
+    "pname": "System.Runtime.Extensions",
+    "version": "4.3.0",
+    "hash": "sha256-wLDHmozr84v1W2zYCWYxxj0FR0JDYHSVRaRuDm0bd/o="
+  },
+  {
+    "pname": "System.Runtime.Handles",
+    "version": "4.3.0",
+    "hash": "sha256-KJ5aXoGpB56Y6+iepBkdpx/AfaJDAitx4vrkLqR7gms="
+  },
+  {
+    "pname": "System.Runtime.InteropServices",
+    "version": "4.3.0",
+    "hash": "sha256-8sDH+WUJfCR+7e4nfpftj/+lstEiZixWUBueR2zmHgI="
+  },
+  {
+    "pname": "System.Runtime.Loader",
+    "version": "4.3.0",
+    "hash": "sha256-syG1GTFjYbwX146BD/L7t55j+DZqpHDc6z28kdSNzx0="
+  },
+  {
+    "pname": "System.Security.AccessControl",
+    "version": "4.7.0",
+    "hash": "sha256-/9ZCPIHLdhzq7OW4UKqTsR0O93jjHd6BRG1SRwgHE1g="
+  },
+  {
+    "pname": "System.Security.AccessControl",
+    "version": "6.0.0",
+    "hash": "sha256-qOyWEBbNr3EjyS+etFG8/zMbuPjA+O+di717JP9Cxyg="
+  },
+  {
+    "pname": "System.Security.Cryptography.Cng",
+    "version": "5.0.0",
+    "hash": "sha256-nOJP3vdmQaYA07TI373OvZX6uWshETipvi5KpL7oExo="
+  },
+  {
+    "pname": "System.Security.Cryptography.Pkcs",
+    "version": "5.0.0",
+    "hash": "sha256-kq/tvYQSa24mKSvikFK2fKUAnexSL4PO4LkPppqtYkE="
+  },
+  {
+    "pname": "System.Security.Cryptography.ProtectedData",
+    "version": "4.4.0",
+    "hash": "sha256-Ri53QmFX8I8UH0x4PikQ1ZA07ZSnBUXStd5rBfGWFOE="
+  },
+  {
+    "pname": "System.Security.Cryptography.ProtectedData",
+    "version": "6.0.0",
+    "hash": "sha256-Wi9I9NbZlpQDXgS7Kl06RIFxY/9674S7hKiYw5EabRY="
+  },
+  {
+    "pname": "System.Security.Permissions",
+    "version": "4.7.0",
+    "hash": "sha256-BGgXMLUi5rxVmmChjIhcXUxisJjvlNToXlyaIbUxw40="
+  },
+  {
+    "pname": "System.Security.Permissions",
+    "version": "6.0.0",
+    "hash": "sha256-/MMvtFWGN/vOQfjXdOhet1gsnMgh6lh5DCHimVsnVEs="
+  },
+  {
+    "pname": "System.Security.Principal.Windows",
+    "version": "4.7.0",
+    "hash": "sha256-rWBM2U8Kq3rEdaa1MPZSYOOkbtMGgWyB8iPrpIqmpqg="
+  },
+  {
+    "pname": "System.Text.Encoding",
+    "version": "4.3.0",
+    "hash": "sha256-GctHVGLZAa/rqkBNhsBGnsiWdKyv6VDubYpGkuOkBLg="
+  },
+  {
+    "pname": "System.Text.Encoding.CodePages",
+    "version": "4.4.0",
+    "hash": "sha256-zD24blG8xhAcL9gC4UTGKetd8c3LO0nv22nKTp2Vfx0="
+  },
+  {
+    "pname": "System.Text.Encodings.Web",
+    "version": "7.0.0",
+    "hash": "sha256-tF8qt9GZh/nPy0mEnj6nKLG4Lldpoi/D8xM5lv2CoYQ="
+  },
+  {
+    "pname": "System.Text.Json",
+    "version": "7.0.1",
+    "hash": "sha256-wtk7fK3c/zAsaPB5oCmD86OfpPEJlGK3npr0mbM1ENM="
+  },
+  {
+    "pname": "System.Threading",
+    "version": "4.3.0",
+    "hash": "sha256-ZDQ3dR4pzVwmaqBg4hacZaVenQ/3yAF/uV7BXZXjiWc="
+  },
+  {
+    "pname": "System.Threading.Tasks",
+    "version": "4.3.0",
+    "hash": "sha256-Z5rXfJ1EXp3G32IKZGiZ6koMjRu0n8C1NGrwpdIen4w="
+  },
+  {
+    "pname": "System.Threading.Tasks.Extensions",
+    "version": "4.5.4",
+    "hash": "sha256-owSpY8wHlsUXn5xrfYAiu847L6fAKethlvYx97Ri1ng="
+  },
+  {
+    "pname": "System.Windows.Extensions",
+    "version": "4.7.0",
+    "hash": "sha256-yW+GvQranReaqPw5ZFv+mSjByQ5y1pRLl05JIEf3tYU="
+  },
+  {
+    "pname": "System.Windows.Extensions",
+    "version": "6.0.0",
+    "hash": "sha256-N+qg1E6FDJ9A9L50wmVt3xPQV8ZxlG1xeXgFuxO+yfM="
+  },
+  {
+    "pname": "ZstdSharp.Port",
+    "version": "0.7.1",
+    "hash": "sha256-VzvKkpVjR7yKQyXhf6Ljf9ikMAQkbPWUiGFOeluanS4="
+  }
+]

pkgs/by-name/ts/tshock/package.nix

@@ -0,0 +1,44 @@
+{
+  lib,
+  fetchFromGitHub,
+  buildDotnetModule,
+  dotnet-sdk_6,
+  dotnet-runtime_6,
+}:
+buildDotnetModule rec {
+  pname = "tshock";
+  version = "5.2.3";
+
+  src = fetchFromGitHub {
+    owner = "Pryaxis";
+    repo = "TShock";
+    rev = "v${version}";
+    sha256 = "sha256-1EtHpBZ7bbwVbl+tMfwpjgPuxu98XKvxlZ2+SbUlWV4=";
+    fetchSubmodules = true;
+  };
+
+  dotnet-sdk = dotnet-sdk_6;
+  dotnet-runtime = dotnet-runtime_6;
+  executables = [ "TShock.Server" ];
+
+  projectFile = [
+    "TShockAPI/TShockAPI.csproj"
+    "TerrariaServerAPI/TerrariaServerAPI/TerrariaServerAPI.csproj"
+    "TShockLauncher/TShockLauncher.csproj"
+    "TShockInstaller/TShockInstaller.csproj"
+    "TShockPluginManager/TShockPluginManager.csproj"
+  ]; # Excluding tests because they can't build for some reason
+
+  doCheck = false; # The same.
+
+  nugetSource = "https://api.nuget.org/v3/index.json";
+  nugetDeps = ./deps.json;
+
+  meta = with lib; {
+    homepage = "https://github.com/Pryaxis/TShock";
+    description = "Modded server software for Terraria, providing a plugin system and inbuilt tools such as anti-cheat, server-side characters, groups, permissions, and item bans";
+    license = licenses.gpl3Only;
+    maintainers = [ maintainers.proggerx ];
+    mainProgram = "TShock.Server";
+  };
+}

pkgs/by-name/ts/tsid/package.nix

@@ -0,0 +1,67 @@
+{
+  cmake,
+  doxygen,
+  eiquadprog,
+  fetchFromGitHub,
+  lib,
+  osqp-eigen,
+  pkg-config,
+  pinocchio,
+  proxsuite,
+  stdenv,
+  pythonSupport ? false,
+  python3Packages,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "tsid";
+  version = "1.8.0";
+
+  src = fetchFromGitHub {
+    owner = "stack-of-tasks";
+    repo = "tsid";
+    rev = "v${finalAttrs.version}";
+    hash = "sha256-SS6JhU4fuZtTzv/EY31ixwwLOzmO/dN3H5HEMh/URTA=";
+  };
+
+  cmakeFlags = [
+    (lib.cmakeBool "BUILD_PYTHON_INTERFACE" pythonSupport)
+    (lib.cmakeBool "BUILD_WITH_OSQP" true)
+    (lib.cmakeBool "BUILD_WITH_PROXQP" true)
+    (lib.cmakeBool "INSTALL_DOCUMENTATION" true)
+  ];
+
+  outputs = [
+    "out"
+    "doc"
+  ];
+
+  nativeBuildInputs = [
+    doxygen
+    cmake
+    pkg-config
+  ]
+  ++ lib.optionals pythonSupport [
+    python3Packages.python
+    python3Packages.pythonImportsCheckHook
+  ];
+
+  propagatedBuildInputs = [
+    eiquadprog
+    osqp-eigen
+    proxsuite
+  ]
+  ++ lib.optional (!pythonSupport) pinocchio
+  ++ lib.optional pythonSupport python3Packages.pinocchio;
+
+  doCheck = true;
+  pythonImportsCheck = [ "tsid" ];
+
+  meta = {
+    description = "Efficient Task Space Inverse Dynamics (TSID) based on Pinocchio";
+    homepage = "https://github.com/stack-of-tasks/tsid";
+    license = lib.licenses.bsd2;
+    maintainers = with lib.maintainers; [ nim65s ];
+    platforms = lib.platforms.unix;
+  };
+})

pkgs/by-name/ts/tslib/package.nix

@@ -0,0 +1,32 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  cmake,
+  nix-update-script,
+}:
+
+stdenv.mkDerivation (finalAttrs: {
+  pname = "tslib";
+  version = "1.23";
+
+  src = fetchFromGitHub {
+    owner = "libts";
+    repo = "tslib";
+    tag = finalAttrs.version;
+    hash = "sha256-2YJDADh/WCksAEIjngAdji98YGmwjpvxSBZkxAwFc7k=";
+  };
+
+  nativeBuildInputs = [ cmake ];
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    description = "Touchscreen access library";
+    homepage = "http://www.tslib.org/";
+    license = lib.licenses.lgpl21;
+    platforms = lib.platforms.linux; # requires linux headers <linux/input.h>
+    maintainers = with lib.maintainers; [ shogo ];
+    teams = with lib.teams; [ ngi ];
+  };
+})

pkgs/by-name/ts/tsm-client/package.nix

@@ -0,0 +1,194 @@
+{
+  lib,
+  callPackage,
+  nixosTests,
+  stdenv,
+  fetchurl,
+  autoPatchelfHook,
+  rpmextract,
+  libxcrypt-legacy,
+  zlib,
+  lvm2, # LVM image backup and restore functions (optional)
+  acl, # EXT2/EXT3/XFS ACL support (optional)
+  gnugrep,
+  procps,
+  jdk, # Java GUI (needed for `enableGui`)
+  buildEnv,
+  makeWrapper,
+  enableGui ? false, # enables Java GUI `dsmj`
+  # path to `dsm.sys` configuration files
+  dsmSysCli ? "/etc/tsm-client/cli.dsm.sys",
+  dsmSysApi ? "/etc/tsm-client/api.dsm.sys",
+}:
+
+# For an explanation of optional packages
+# (features provided by them, version limits), see
+# https://web.archive.org/web/20240118051918/https://www.ibm.com/support/pages/node/660813#Version%208.1
+
+# IBM Tivoli Storage Manager Client uses a system-wide
+# client system-options file `dsm.sys` and expects it
+# to be located in a directory within the package.
+# Note that the command line client and the API use
+# different "dms.sys" files (located in different directories).
+# Since these files contain settings to be altered by the
+# admin user (e.g. TSM server name), we create symlinks
+# in place of the files that the client attempts to open.
+# Use the arguments `dsmSysCli` and `dsmSysApi` to
+# provide the location of the configuration files for
+# the command-line interface and the API, respectively.
+#
+# While the command-line interface contains wrappers
+# that help the executables find the configuration file,
+# packages that link against the API have to
+# set the environment variable `DSMI_DIR` to
+# point to this derivations `/dsmi_dir` directory symlink.
+# Other environment variables might be necessary,
+# depending on local configuration or usage; see:
+# https://www.ibm.com/docs/en/storage-protect/8.1.27?topic=solaris-set-api-environment-variables
+
+let
+
+  meta = {
+    homepage = "https://www.ibm.com/products/storage-protect";
+    downloadPage = "https://www.ibm.com/support/fixcentral/swg/selectFixes?product=ibm/StorageSoftware/IBM+Spectrum+Protect";
+    platforms = [ "x86_64-linux" ];
+    mainProgram = "dsmc";
+    sourceProvenance = with lib.sourceTypes; [ binaryNativeCode ];
+    license = lib.licenses.unfree;
+    maintainers = [ lib.maintainers.yarny ];
+    description = "IBM Storage Protect (Tivoli Storage Manager) CLI and API";
+    longDescription = ''
+      IBM Storage Protect (Tivoli Storage Manager) provides
+      a single point of control for backup and recovery.
+      This package contains the client software, that is,
+      a command line client and linkable libraries.
+
+      Note that the software requires a system-wide
+      client system-options file (commonly named "dsm.sys").
+      This package allows to use separate files for
+      the command-line interface and for the linkable API.
+      The location of those files can
+      be provided as build parameters.
+    '';
+  };
+
+  passthru.tests = {
+    test-cli = callPackage ./test-cli.nix { };
+    test-gui = nixosTests.tsm-client-gui;
+  };
+
+  mkSrcUrl =
+    version:
+    let
+      major = lib.versions.major version;
+      minor = lib.versions.minor version;
+      patch = lib.versions.patch version;
+      fixup = lib.lists.elemAt (lib.versions.splitVersion version) 3;
+    in
+    "https://public.dhe.ibm.com/storage/tivoli-storage-management/${
+      if fixup == "0" then "maintenance" else "patches"
+    }/client/v${major}r${minor}/Linux/LinuxX86/BA/v${major}${minor}${patch}/${version}-TIV-TSMBAC-LinuxX86.tar";
+
+  unwrapped = stdenv.mkDerivation (finalAttrs: {
+    name = "tsm-client-${finalAttrs.version}-unwrapped";
+    version = "8.1.27.0";
+    src = fetchurl {
+      url = mkSrcUrl finalAttrs.version;
+      hash = "sha512-nbQHoD7fUp4qBTgRJ6nHXF4PsZRTin7FGPi340jKc73O/9DCNb1JQG/gY+B2xzPM2g6agqWu/MX5J+Wt0nOEkA==";
+    };
+    inherit meta passthru;
+
+    nativeBuildInputs = [
+      autoPatchelfHook
+      rpmextract
+    ];
+    buildInputs = [
+      libxcrypt-legacy
+      stdenv.cc.cc
+      zlib
+    ];
+    runtimeDependencies = [
+      (lib.attrsets.getLib lvm2)
+    ];
+    sourceRoot = ".";
+
+    postUnpack = ''
+      rpmextract TIVsm-API64.x86_64.rpm
+      rpmextract TIVsm-APIcit.x86_64.rpm
+      rpmextract TIVsm-BA.x86_64.rpm
+      rpmextract TIVsm-BAcit.x86_64.rpm
+      rpmextract TIVsm-BAhdw.x86_64.rpm
+      rpmextract TIVsm-JBB.x86_64.rpm
+      # use globbing so that version updates don't break the build:
+      rpmextract gskcrypt64-*.linux.x86_64.rpm
+      rpmextract gskssl64-*.linux.x86_64.rpm
+    '';
+
+    installPhase = ''
+      runHook preInstall
+      mkdir --parents $out
+      mv --target-directory=$out usr/* opt
+      runHook postInstall
+    '';
+
+    # fix symlinks pointing to `..../opt/....`
+    preFixup = ''
+      for link in $(find $out -type l -lname '*../opt*')
+      do
+        ln --symbolic --force --no-target-directory "$(readlink "$link" | sed 's|../opt|opt|')" "$link"
+      done
+    '';
+  });
+
+  binPath = lib.makeBinPath (
+    [
+      acl
+      gnugrep
+      procps
+    ]
+    ++ lib.optional enableGui jdk
+  );
+
+in
+
+buildEnv {
+  name = "tsm-client-${unwrapped.version}";
+  meta =
+    meta
+    // lib.attrsets.optionalAttrs enableGui {
+      mainProgram = "dsmj";
+    };
+  passthru = passthru // {
+    inherit unwrapped;
+  };
+  paths = [ unwrapped ];
+  nativeBuildInputs = [ makeWrapper ];
+  pathsToLink = [
+    "/"
+    "/bin"
+    "/opt/tivoli/tsm/client/ba/bin"
+    "/opt/tivoli/tsm/client/api/bin64"
+  ];
+  # * Provide top-level symlinks `dsm_dir` and `dsmi_dir`
+  #   to the so-called "installation directories"
+  # * Add symlinks to the "installation directories"
+  #   that point to the `dsm.sys` configuration files
+  # * Drop the Java GUI executable unless `enableGui` is set
+  # * Create wrappers for the command-line interface to
+  #   prepare `PATH` and `DSM_DIR` environment variables
+  postBuild = ''
+    ln --symbolic --no-target-directory opt/tivoli/tsm/client/ba/bin $out/dsm_dir
+    ln --symbolic --no-target-directory opt/tivoli/tsm/client/api/bin64 $out/dsmi_dir
+    ln --symbolic --no-target-directory "${dsmSysCli}" $out/dsm_dir/dsm.sys
+    ln --symbolic --no-target-directory "${dsmSysApi}" $out/dsmi_dir/dsm.sys
+    ${lib.optionalString (!enableGui) "rm $out/bin/dsmj"}
+    for bin in $out/bin/*
+    do
+      target=$(readlink "$bin")
+      rm "$bin"
+      makeWrapper "$target" "$bin" \
+        --prefix PATH : "$out/dsm_dir:${binPath}" \
+        --set DSM_DIR $out/dsm_dir
+    done
+  '';
+}

pkgs/by-name/ts/tsm-client/test-cli.nix

@@ -0,0 +1,59 @@
+{
+  lib,
+  writeText,
+  runCommand,
+  tsm-client,
+}:
+
+# Let the client try to connect to a server.
+# We can't simulate a server, so there's no more to test.
+
+let
+
+  # 192.0.0.8 is a "dummy address" according to RFC 7600
+  dsmSysCli = writeText "cli.dsm.sys" ''
+    defaultserver  testserver
+    server  testserver
+      commmethod  v6tcpip
+      tcpserveraddress  192.0.0.8
+      nodename  ARBITRARYNODENAME
+  '';
+
+  tsm-client_ = tsm-client.override { inherit dsmSysCli; };
+
+  env.nativeBuildInputs = [ tsm-client_ ];
+
+  versionString =
+    let
+      inherit (tsm-client_.passthru.unwrapped) version;
+      major = lib.versions.major version;
+      minor = lib.versions.minor version;
+      patch = lib.versions.patch version;
+      fixup = lib.lists.elemAt (lib.versions.splitVersion version) 3;
+    in
+    "Client Version ${major}, Release ${minor}, Level ${patch}.${fixup}";
+
+in
+
+runCommand "${tsm-client.name}-test-cli" env ''
+  set -o nounset
+  set -o pipefail
+
+  export DSM_LOG=$(mktemp -d ./dsm_log.XXXXXXXXXXX)
+
+  { dsmc -optfile=/dev/null || true; } | tee dsmc-stdout
+
+  # does it report the correct version?
+  grep --fixed-strings '${versionString}' dsmc-stdout
+
+  # does it use the provided dsm.sys config file?
+  # if it does, it states the node's name
+  grep ARBITRARYNODENAME dsmc-stdout
+
+  # does it try (and fail) to connect to the server?
+  # if it does, it reports the "TCP/IP connection failure" error code
+  grep ANS1017E dsmc-stdout
+  grep ANS1017E $DSM_LOG/dsmerror.log
+
+  touch $out
+''

pkgs/by-name/ts/tsocks/package.nix

@@ -0,0 +1,46 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+}:
+
+stdenv.mkDerivation rec {
+  pname = "tsocks";
+  version = "1.8beta5";
+
+  src = fetchurl {
+    url = "mirror://sourceforge/tsocks/${pname}-${version}.tar.gz";
+    sha256 = "0ixkymiph771dcdzvssi9dr2pk1bzaw9zv85riv3xl40mzspx7c4";
+  };
+
+  patches = [ ./poll.patch ];
+
+  preConfigure = ''
+    sed -i -e "s,\\\/usr,"$(echo $out|sed -e "s,\\/,\\\\\\\/,g")",g" tsocks
+    substituteInPlace configure \
+      --replace-fail "main(){return(0);}" "int main(){return(0);}"
+    substituteInPlace tsocks --replace /usr $out
+  '';
+
+  configureFlags = [
+    "--libdir=${placeholder "out"}/lib"
+  ];
+
+  preBuild = ''
+    # We don't need the saveme binary, it is in fact never stored and we're
+    # never injecting stuff into ld.so.preload anyway
+    sed -i \
+      -e "s,TARGETS=\(.*\)..SAVE.\(.*\),TARGETS=\1\2," \
+      -e "/SAVE/d" Makefile
+  '';
+
+  meta = with lib; {
+    description = "Transparent SOCKS v4 proxying library";
+    mainProgram = "tsocks";
+    homepage = "https://tsocks.sourceforge.net/";
+    license = lib.licenses.gpl2;
+    maintainers = with maintainers; [ edwtjo ];
+    platforms = platforms.unix;
+    broken = stdenv.hostPlatform.isDarwin;
+  };
+}

pkgs/by-name/ts/tsocks/poll.patch

@@ -0,0 +1,26 @@
+From Ingo Hadan <ingo.hadan@sdm.de> Fri, 02 Apr 2010 21:08:50 +0200
+From: Julien Moutinho <julm+tsocks@autogeree.net>
+Date: Fri, 26 Apr 2013 01:57:26 +0200
+Subject: tsocks fails if socksified application uses poll(2) (e.g. subversion-1.5)
+
+---
+diff --git a/tsocks.c b/tsocks.c
+index 9cfdfff..470babd 100644
+--- a/tsocks.c
++++ b/tsocks.c
+@@ -657,10 +657,11 @@ int poll(POLL_SIGNATURE) {
+              * be ready for writing), otherwise we'll just let the select loop
+              * come around again (since we can't flag it for read, we don't know
+              * if there is any data to be read and can't be bothered checking) */
+-            if (conn->selectevents & WRITE) {
+-               setevents |= POLLOUT; 
++            if (conn->selectevents & POLLOUT) {
++               ufds[i].revents |= POLLOUT; 
+                nevents++;
+             }
++            ufds[i].events = conn->selectevents;
+          }
+       }
+    } while (nevents == 0);
+
+

pkgs/by-name/ts/tsukae/package.nix

@@ -0,0 +1,27 @@
+{
+  lib,
+  fetchFromGitHub,
+  buildGoModule,
+}:
+
+buildGoModule {
+  pname = "tsukae";
+  version = "0-unstable-2021-04-19";
+
+  src = fetchFromGitHub {
+    owner = "irevenko";
+    repo = "tsukae";
+    rev = "8111dddd67e4b4f83ae4bca7d7305f6dc64e77cd";
+    sha256 = "sha256-1y/WYLW6/HMGmuaX2wOlQbwYn0LcgQCMb4qw8BtCgxQ=";
+  };
+
+  vendorHash = "sha256-Q0WOzyJGnTXTmj7ZPKyVSnWuWb4bbDjDpgftQ1Opf/I=";
+
+  meta = with lib; {
+    description = "Show off your most used shell commands";
+    homepage = "https://github.com/irevenko/tsukae";
+    license = licenses.mit;
+    mainProgram = "tsukae";
+    maintainers = with maintainers; [ l3af ];
+  };
+}

pkgs/by-name/ts/tsukimi/package.nix

@@ -0,0 +1,84 @@
+{
+  lib,
+  fetchFromGitHub,
+  rustPlatform,
+  pkg-config,
+  mpv-unwrapped,
+  ffmpeg,
+  libadwaita,
+  gst_all_1,
+  openssl,
+  libepoxy,
+  wrapGAppsHook4,
+  nix-update-script,
+  stdenv,
+  meson,
+  ninja,
+  rustc,
+  cargo,
+  dbus,
+  desktop-file-utils,
+  versionCheckHook,
+}:
+stdenv.mkDerivation rec {
+  pname = "tsukimi";
+  version = "0.21.0";
+
+  src = fetchFromGitHub {
+    owner = "tsukinaha";
+    repo = "tsukimi";
+    tag = "v${version}";
+    hash = "sha256-FmxNOMYHoQK//v4ZGvJ6vIHKYgMfQm7LTwQV9iEFo0A=";
+  };
+
+  cargoDeps = rustPlatform.fetchCargoVendor {
+    inherit src;
+    hash = "sha256-iH7vCZhCN2/gu2EC+YG/LUL9N/HMMnj7qHqXUdrlAh8=";
+  };
+
+  nativeBuildInputs = [
+    pkg-config
+    wrapGAppsHook4
+    meson
+    ninja
+    rustPlatform.cargoSetupHook
+    rustc
+    cargo
+    desktop-file-utils
+  ];
+
+  buildInputs = [
+    mpv-unwrapped
+    ffmpeg
+    libadwaita
+    openssl
+    libepoxy
+    dbus
+  ]
+  ++ (with gst_all_1; [
+    gstreamer
+    gst-plugins-base
+    gst-plugins-good
+    gst-plugins-bad
+    gst-plugins-ugly
+    gst-libav
+  ]);
+
+  nativeInstallCheckInputs = [ versionCheckHook ];
+  versionCheckProgramArg = "--version";
+  doInstallCheck = true;
+
+  passthru.updateScript = nix-update-script { };
+
+  meta = {
+    description = "Simple third-party Emby client, featured with GTK4-RS, MPV and GStreamer";
+    homepage = "https://github.com/tsukinaha/tsukimi";
+    license = lib.licenses.gpl3Plus;
+    maintainers = with lib.maintainers; [
+      merrkry
+      aleksana
+    ];
+    mainProgram = "tsukimi";
+    platforms = lib.platforms.linux;
+  };
+}

pkgs/by-name/ts/tsung/package.nix

@@ -0,0 +1,60 @@
+{
+  lib,
+  stdenv,
+  fetchurl,
+  makeWrapper,
+  erlang,
+  python3,
+  python3Packages,
+  perlPackages,
+  gnuplot,
+}:
+
+stdenv.mkDerivation rec {
+  pname = "tsung";
+  version = "1.8.0";
+
+  src = fetchurl {
+    url = "http://tsung.erlang-projects.org/dist/tsung-${version}.tar.gz";
+    hash = "sha256-kehkMCYBfj0AiKZxD7EcT2F0d+gm6+TF/lhqpjFH/JI=";
+  };
+
+  nativeBuildInputs = [
+    makeWrapper
+  ];
+
+  propagatedBuildInputs = [
+    erlang
+    gnuplot
+    perlPackages.perl
+    perlPackages.TemplateToolkit
+    python3
+    python3Packages.matplotlib
+  ];
+
+  postFixup = ''
+    # Make tsung_stats.pl accessible
+    # Leaving .pl at the end since all of tsung documentation is refering to it
+    # as tsung_stats.pl
+    ln -s $out/lib/tsung/bin/tsung_stats.pl $out/bin/tsung_stats.pl
+
+    # Add Template Toolkit and gnuplot to tsung_stats.pl
+    wrapProgram $out/bin/tsung_stats.pl \
+        --prefix PATH : ${lib.makeBinPath [ gnuplot ]} \
+        --set PERL5LIB "${perlPackages.makePerlPath [ perlPackages.TemplateToolkit ]}"
+  '';
+
+  meta = {
+    homepage = "http://tsung.erlang-projects.org/";
+    changelog = "https://github.com/processone/tsung/blob/v${version}/CHANGELOG.md";
+    description = "High-performance benchmark framework for various protocols including HTTP, XMPP, LDAP, etc";
+    longDescription = ''
+      Tsung is a distributed load testing tool. It is protocol-independent and
+      can currently be used to stress HTTP, WebDAV, SOAP, PostgreSQL, MySQL,
+      AMQP, MQTT, LDAP and Jabber/XMPP servers.
+    '';
+    license = lib.licenses.gpl2Plus;
+    maintainers = with lib.maintainers; [ uskudnik ];
+    platforms = lib.platforms.unix;
+  };
+}

pkgs/by-name/ts/tsx/package.nix

@@ -0,0 +1,93 @@
+{
+  lib,
+  stdenv,
+  fetchFromGitHub,
+  pnpm_9,
+  nodejs_22,
+  versionCheckHook,
+}:
+stdenv.mkDerivation rec {
+  pname = "tsx";
+  version = "4.19.3";
+
+  src = fetchFromGitHub {
+    owner = "privatenumber";
+    repo = "tsx";
+    tag = "v${version}";
+    hash = "sha256-wdv2oqJNc6U0Fyv4jT+0LUcYaDfodHk1vQZGMdyFF/E=";
+  };
+
+  pnpmDeps = pnpm_9.fetchDeps {
+    inherit pname version src;
+    fetcherVersion = 1;
+    hash = "sha256-57KDZ9cHb7uqnypC0auIltmYMmIhs4PWyf0HTRWEFiU=";
+  };
+
+  nativeBuildInputs = [
+    nodejs_22
+    pnpm_9.configHook
+  ];
+
+  buildInputs = [
+    nodejs_22
+  ];
+
+  patchPhase = ''
+    runHook prePatch
+
+    # by default pnpm builds the docs workspace and this was just
+    #  the easiest way I found to stop that, as pnpmWorkspaces and
+    #  other flags did not work
+    rm pnpm-workspace.yaml
+
+    # because tsx uses semantic-release, the package.json has a placeholder
+    #  version number. this patches it to match the version of the nix package,
+    #  which in turn is the release version in github.
+    substituteInPlace package.json --replace-fail "0.0.0-semantic-release" "${version}"
+
+    runHook postPatch
+  '';
+
+  buildPhase = ''
+    runHook preBuild
+
+    npm run build
+
+    # remove devDependencies that are only required to build
+    #  and package the typescript code
+    CI=true pnpm prune --prod
+
+    # Clean up broken symlinks left behind by `pnpm prune`
+    # https://github.com/pnpm/pnpm/issues/3645
+    find node_modules -xtype l -delete
+
+    runHook postBuild
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/{bin,lib/tsx}
+    cp -r {dist,node_modules} $out/lib/tsx
+    chmod +x $out/lib/tsx/dist/cli.mjs
+    ln -s $out/lib/tsx/dist/cli.mjs $out/bin/tsx
+
+    runHook postInstall
+  '';
+
+  # 8 / 85 tests are failing, I do not know why, while regular usage shows no issues.
+  doCheck = false;
+  nativeInstallCheckInputs = [
+    versionCheckHook
+  ];
+  doInstallCheck = true;
+  versionCheckProgramArg = "--version";
+
+  meta = {
+    description = "TypeScript Execute (tsx): The easiest way to run TypeScript in Node.js";
+    homepage = "https://tsx.is";
+    license = lib.licenses.mit;
+    maintainers = [ lib.maintainers.sdedovic ];
+    mainProgram = "tsx";
+  };
+}