Niente di insuperabile comunque. Vi lascio qui sotto un breve programmino in c# in grado di far partire un reboot sui modelli della famiglia:

using System;
using System.IO;
using System.Net;
using System.Text;

namespace RebootRouter2
{
    class Program
    {
        static void Main(string[] args)
        {
            var address = "http://192.168.2.1";/
            var username = "admin";
            var password = "admin";

            var request = (HttpWebRequest)WebRequest.Create(address + "/cgi?7");

            request.CookieContainer = new CookieContainer();
            request.CookieContainer.Add(new Uri(address), new Cookie("Authorization", "Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(username + ":" + password))));
            request.Referer = address;
            request.Headers["Origin"] = address;

            var postData = "[ACT_REBOOT#0,0,0,0,0,0#0,0,0,0,0,0]0,0\r\n";
            var data = Encoding.ASCII.GetBytes(postData);

            request.Method = "POST";
            request.ContentType = "text/plain";
            request.ContentLength = data.Length;

            using (var stream = request.GetRequestStream())
            {
                stream.Write(data, 0, data.Length);
            }

            var response = (HttpWebResponse)request.GetResponse();

            var responseString = new StreamReader(response.GetResponseStream()).ReadToEnd();

            Console.WriteLine(responseString);
        }
    }
}

E anche uno in bash:

#!/bin/bash

ROUTER="http://192.168.2.1"/
AUTH=$(echo -n "user:pass" | base64)
CURL="/usr/bin/curl -s -o /dev/null -w %{http_code} -H 'Referer: $ROUTER' -H 'Origin: $ROUTER' -b 'Authorization=Basic $AUTH' $ROUTER"

HTTP_CODE=$(eval $CURL)

if [ "$HTTP_CODE" == "200" ]; then
HTTP_CODE=$(/usr/bin/printf "[ACT_REBOOT#0,0,0,0,0,0#0,0,0,0,0,0]0,0\r\n" | eval $CURL/cgi?7 --data-binary @-)
fi

if [ "$HTTP_CODE" == "200" ]; then
echo "Reboot request accepted."
else
echo "Reboot request not accepted. ($HTTP_CODE)"
fi

Mi sono chiesto perché l’avevo creato così, considerato che su un i7 con 4+4 core, la potenza di calcolo disponibile era più che sprecata.

Problema risolto.

static void Main(string[] args)
{
    DirectoryInfo di = new DirectoryInfo(@"root");

    ConcurrentQueue<FileInfo> q = new ConcurrentQueue<FileInfo>(di.GetFiles("*", SearchOption.AllDirectories));

    for (int i = 0; i < Environment.ProcessorCount; i++)
    {
        Thread t = new Thread(new ParameterizedThreadStart(thread));
        t.Start(q);
    }
}

static void thread(object b)
{
    ConcurrentQueue<FileInfo> q = (ConcurrentQueue<FileInfo>)b;
            
    while(!q.IsEmpty)
    {
        FileInfo f;
        if(q.TryDequeue(out f))
            compressFile(f);
    }
}

static void compressFile(FileInfo f)
{
    if (!f.Name.StartsWith(".") && f.Extension != ".php" && f.Extension != ".gz" && f.Extension != ".ini")
    {
        FileInfo f2 = new FileInfo(f.FullName + ".gz");

        if (f.LastWriteTime > f2.LastWriteTime)
        {
            ProcessStartInfo psi = new ProcessStartInfo("gzip.exe", "-9 -k -f \"" + f.FullName + "\"");
            psi.CreateNoWindow = true;
            psi.UseShellExecute = false;
            psi.WindowStyle = ProcessWindowStyle.Hidden;
            Process.Start(psi).WaitForExit();

            f2.Refresh();
        }

        if (f2.Exists && f2.Length >= f.Length)
            f2.Delete();
    }
}

Procuratevi gzip per la vostra piattaforma (potete farlo anche direttamente sul server se avete l’accesso alla shell) e comprimete i file statici. Ricordate di lasciare anche il file originale in caso il browser non voglia quello compresso. Evitate inoltre di comprimere i file dinamici, tipo i .php.

Una volta fatto questo, impostate questa regola di apache:

<IfModule mod_rewrite.c>
RewriteEngine on
RewriteBase /
RewriteOptions Inherit
ReWriteCond %{HTTP:accept-encoding} (gzip.*)
ReWriteCond %{REQUEST_FILENAME} !.+\.gz$
RewriteCond %{REQUEST_FILENAME}.gz -f
RewriteRule (.+) $1.gz [QSA,L]
</IfModule>

Il significato è questo: se il browser accetta file compressi con gzip e una versione compressa esiste, invia il file che si chiama nomeoriginale.gz; altrimenti invia nomeoriginale.

Se volete, potete anche comprimere l’output dei file php tramite php.ini:

zlib.output_compression = On
zlib.output_compression_level = 5

Queste due tecniche consentono di risparmiare mediamente il 50% dei dati inviati. Ovviamente il rendimento cambia da file a file, ma sicuramente un miglioramento lo vedrete.

Un piccolo consiglio: quando comprimete, verificate sempre che il file originale non sia più piccolo di quello compresso. La cosa non è scontata.

Vi lascio il programmino che ho usato per comprimere questo sito.

static void Main(string[] args)
{
    DirectoryInfo di = new DirectoryInfo("root");
    foreach (FileInfo f in di.GetFiles("*", SearchOption.AllDirectories))
    {
        if(!f.Name.StartsWith(".") && f.Extension != ".php" && f.Extension != ".gz")
        {
            ProcessStartInfo psi = new ProcessStartInfo("gzip.exe", "-9 -k -f \"" + f.FullName + "\"");
            psi.CreateNoWindow = true;
            psi.UseShellExecute = false;
            psi.WindowStyle = ProcessWindowStyle.Hidden;
            Process.Start(psi).WaitForExit();

            FileInfo f2 = new FileInfo(f.FullName + ".gz");

            if(f2.Exists)
                if(f2.Length >= f.Length)
                    f2.Delete();
        }
    }
}

Decido quindi di convertire la libreria in MP3 (320k).

Siccome un programmatore non è contento se non fa le cose da sé, ho scritto un piccolo wrapper per ffmpeg (che a sua volta include le librerie LAME) avendo cura che le conversioni occupino tutta la potenza di calcolo disponibile, lanciando una istanza per core.

Per evitare di incorrere in elaborazioni “doppione”, è necessario sincronizzare i thread affinché si eviti che più di un thread gestisca un singolo file.

Ci viene in aiuto il namespace System.Collections.Concurrent che include delle collezioni concepite allo scopo.

Nella fattispecie, ho scelto ConcurrentQueue per la sua logica FIFO (First In First Out).

Per Queue si intende una coda, proprio come quella del supermercato o delle poste: chi prima arriva, prima se ne va.

Per questo tipo di applicazione poteva andar bene anche uno Stack (pila) con logica LIFO (Last In First Out) perché l’ordine in cui vengono convertiti i file non è importante.

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Collections.Concurrent;
 
namespace mp320kenc
{
    class Program
    {
        static string encpath = getResourceFullPath("ffmpeg.exe");
 
        static void Main(string[] args)
        {
            if(args.Length > 0)
            {
                ConcurrentQueue<filetoencode> q = new ConcurrentQueue<filetoencode>();
                string dir = args[0];
                DirectoryInfo di = new DirectoryInfo(dir);
                string newdir = di.Parent.CreateSubdirectory(di.Name + " - MP3").FullName;
 
                foreach(FileInfo f in di.GetFiles())
                {
                    string ext = f.Extension.ToLower();
 
                    if(ext == ".wav" || ext == ".flac")
                    {
                        q.Enqueue(new filetoencode(f.FullName, Path.Combine(newdir, Path.GetFileNameWithoutExtension(f.Name)+".mp3")));
                    }
                }
 
                for (int i = 0; i < Environment.ProcessorCount; i++)
                {
                    System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(encode));
                    t.Start(q);
                }
            }
        }
        static void encode(object b)
        {
            ConcurrentQueue<filetoencode> q = (ConcurrentQueue<filetoencode>)b;
 
            while (!q.IsEmpty)
            {
                filetoencode enc;
                if(q.TryDequeue(out enc))
                {
                    Console.WriteLine("Encoding " + Path.GetFileName(enc.path));
                    ProcessStartInfo p = getPCI(enc.path, enc.dest);
                    Process.Start(p).WaitForExit();
                }
            }
        }
        public static String getResourceFullPath(String name)
        {
            return Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase), name).Substring(6);
        }
        private static ProcessStartInfo getPCI(string oldpath, string newpath)
        {
            ProcessStartInfo p = new ProcessStartInfo();
            p.WindowStyle = ProcessWindowStyle.Hidden;
            p.CreateNoWindow = true;
            p.UseShellExecute = false;
            p.Arguments = String.Format("-i "{0}" -acodec mp3 -b:a 320k "{1}"",oldpath,newpath);
            p.FileName = encpath;
            return p;
        }
        class filetoencode
        {
            public string path;
            public string dest;
 
            public filetoencode(string p, string de)
            {
                path = p;
                dest = de;
            }
        }
    }
}