staging.inyokaproject.org

Ich versuche gerade einen neuen Server zu basteln. Hatte ich schon mal gemacht, was auch funktioniert hatte. Aber jetzt ist es etwas anders.

Es geht darum, dass ein normaler Benutzer einfach einen Server, in einem bestimmten Verzeichnis, starten kann und damit eine Freigabe erstellt, die mit Beendigung des Servers zurückgezogen ist.

Der Grund für diese Vorgehensweise ist, dass der Server Zugriff auf die lokalen und individualisierten (durch ein anderes Programm erzeugten) Vorschaudateien und den darin möglicherweise enthaltenen Metadaten haben soll. Das bekomme ich mit "normalen" Servern und PHP nicht hin, da diese unter einem eigenen Benutzernamen laufen und damit keinen Zugriff auf sensible Daten des Benutzers (Thumbnails) keinen Zugriff haben.

Das Problem entsteht jetzt dadurch, dass in der erzeugten Web-Site die kompletten Pfade nicht sichtbar sein sollen. Es sollen nur Namen unterhalb des freigegebenen Verzeichnisses sichtbar sein. Das bedeutet, das der Server den Clients u.a. einige (konstante) Variablen (gr) bereitstellen muss. Als da sind:

• home_dir

• cache_dir

• thumb_base_dir

• thumb_sub_dir

Das ist notwendig, damit die Angaben aus der generierten HTML Seite serverseitig so ergänzt werden können, dass eine Funktionalität gegeben ist.

Die Frage ist jetzt, ob das ohne den Einsatz von Shared-Memory / Maped-Memory (mmap hatte ich schon verwendet) möglich ist. Mein Englisch ist jetzt nicht so gut, dass ich aus den Dokumentationen sicher herauslesen könnte, dass ein rein lesender Zugriff ohne weiteres möglich wäre. Wenn das ginge, wäre das eine deutliche Vereinvachung. Bei mmap() müsste ich ja auch die Größe des Datenblocks angeben, der ja nicht unbedingt bekannt sein muss.

Dakuan schrieb:

[…] ein normaler Benutzer einfach einen Server, in einem bestimmten Verzeichnis, starten kann und damit eine Freigabe erstellt, die mit Beendigung des Servers zurückgezogen ist.

Was für ein Server? Beim Protokoll SMB ist das genau das, was net usershare machen soll. → Samba Server/net usershare

Allgemein ist dafür erforderlich, dass der Server einen Port >1023 verwendet.

Der Grund für diese Vorgehensweise ist, dass der Server Zugriff auf die lokalen und individualisierten (durch ein anderes Programm erzeugten) Vorschaudateien und den darin möglicherweise enthaltenen Metadaten haben soll. Das bekomme ich mit "normalen" Servern und PHP nicht hin, da diese unter einem eigenen Benutzernamen laufen und damit keinen Zugriff auf sensible Daten des Benutzers (Thumbnails) keinen Zugriff haben.

Das ist ein reines Berechtigungsproblem. Wenn der Systembenutzer, unter dem der Server läuft, wirklich auf Dateien eines normalen Benutzers zugreifen können soll, benötigt er dafür ja nur Rechte im Homeverzeichnis des normalen Benutzers. Normalerweise (Dateirechte im Homeverzeichnis 64X/75X) recht dafür aus, dass der Benutzer den Systembenutzer für den Server in seine primäre Gruppe aufnimmt oder man verwendet Dateirechte 644/755. → Rechte

Der Server soll den Inhalt eines Verzeichnisses als HTML Dokument ausliefern zusammen mit den zugehörigen Vorschaudateien. Die Vorschaudateien haben die Dateirechte 600.

Der Server soll am Port 8080 lauschen, was der Benutzer aber beim Aufruf ändern kann.

Bei SMB Freigaben muss der Client die Vorschaudateien selber erzeugen. Dazu muss er die Dateien erstmal herunterladen, was bei Videos etwas unpraktisch ist. Außerdem tut mein Tablet sich mit SBM schwer.

Mit den "gemeinsamen Variablen" wollte ich vermeiden, dass ein Kindprozess des Servers diese Daten bei jedem Aufruf neu ermitteln muss.

Bei einem fork() wird eine Kopie des Speichers des Elternprozess für den Kindprozess erzeugt: https://manpages.ubuntu.com/manpages/noble/de/man2/fork.2.html - also kann man darüber leicht Variablen an den Kindprozess übergeben - z.B.:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    const char* variable = "foo";
    printf("Parent PID: %d\n", getpid());
    pid_t p = fork();
    if (p<0) {
        perror("fork failed");
        exit(1);
    } else if (p == 0) {
	printf("Hello from the child: Process id: %d; Variable: %s\n", getpid(), variable);
    } else {
        printf("Hello from the parent: Process id: %d; Variable: %s\n", getpid(), variable);
    }
}

Der Nachteil ist, dass alles kopiert wird - je nachdem, was man braucht kann es schlanker sein einen eigenen Thread zu starten und dem die nötigen Informationen mitzugeben oder ein eigenständiges Programm, dem man per IPC sagen kann, welche Verzeichnisse freigegeben werden sollen - das das skaliert bei einer großen Menge von Freigaben besser als für jede Freigabe einen extra Thread/Prozess zu haben.

Hallo seahawk1986 in deinem Beispiel sieht es so aus, dass auch lokale Variablen (zumindest die aus main() ) kopiert werden. Ich kann gerade nicht überblicken wie viel das bei mir ist, da ich das Zeugs für die Netzwerkinitialisierung erst nachschauen müsste - also das hier:

1
2
3
4
5
6
7
8
9

int main( int argc, char *argv[] ) {
    ...
    struct addrinfo hints;
    struct addrinfo *result, *rp;
    #define ADDRSTRLEN (NI_MAXHOST+NI_MAXSERV+10)
    char            addrStr[ADDRSTRLEN];
    char            host[NI_MAXHOST];
    char            service[NI_MAXSERV];
    ...

Ich fürchte das sind einige kb, die die Kindprozesse nicht benötigen.

Für Thread basierte Server ist mir noch kein funktionierendes Beispiel vor die Füße gefallen. Auch in "The Linux Programming Interface" sind nur klassische Beispiele mit fork(). Alles, was ich bisher davon abgeleitet hatte, funktioniert.

Das mit den Verzeichnisfreigaben ist unkritisch. Es ist immer nur das Verzeichnis, in dem der Server gestartet wird. Aber ich will nicht den kompletten Dateipfad im HTML Dokument haben und auch nicht den zum Basisverzeichnis der Vorschaudateien (den kann man auch nicht gut hart codieren, da er nicht in Stein gemeißelt ist). Das müssen also die Serverprozesse ergänzen.

Große Last ist nicht zu erwarten, aber ich möchte auch keine großen Verzögerungen. In einer anderen Anwendung, wo die Vorschaudateien noch analysiert werden müssen, habe ich teilweise 40 sec Wartezeit.

Dakuan schrieb:

Der Server soll den Inhalt eines Verzeichnisses als HTML Dokument ausliefern zusammen mit den zugehörigen Vorschaudateien. Die Vorschaudateien haben die Dateirechte 600.

Ich verstehe immer noch nicht genau den Anwendungsbereich?

Der Server soll am Port 8080 lauschen, was der Benutzer aber beim Aufruf ändern kann.

Warum machst du das nicht mit webdav?

Bei SMB Freigaben muss der Client die Vorschaudateien selber erzeugen. Dazu muss er die Dateien erstmal herunterladen, was bei Videos etwas unpraktisch ist. Außerdem tut mein Tablet sich mit SBM schwer.

Es soll für ein Tablet sein, warum legst du die Daten dann nicht einfach in ein zentrales Verzeichnis, da kannst du ja die Rechte so setzen wie du sie brauchst?

Und ich verstehe immer noch nicht den Anwendungsbereich, warum willst du das so lösen. Ich sage zu meinen Usern immer bitte eine Userstorry und keine Lösung.

Bitte beschreibe detaillierte was dein ZIEL ist, dann können wir vermutlich besser Lösungen anbieten

PS: bei über 6000 Beiträge hier im Forum musst du doch schon ein Profi in Sachen Ubuntu sein?

... warum legst du die Daten dann nicht einfach in ein zentrales Verzeichnis, da kannst du ja die Rechte so setzen wie du sie brauchst?

Das wäre dann aber ein geplanter Server, den man auch warten muss. Früher hatte ich für solche Zwecke lighttpd (mit PHP) und bozohttpd (Wartungsmodus) eingesetzt. Aber jetzt möchte ich eine Lösung, die ich, bei Bedarf, spontan einsetzen kann, also ohne vorherige Planung.

PS: bei über 6000 Beiträge hier im Forum musst du doch schon ein Profi in Sachen Ubuntu sein?

Das ist ein Trugschluss. Viele Dinge ändern sich (gefühlt) schneller als ich lesen kann. Und nicht alles, was Ubuntu neu einführt, gefällt mir. Aber das hat nichts mit meiner Frage zu tun. Außerdem bin ich auch mit einigen anderen Distries unterwegs.

Als Hobbyprogrammierer bin ich bei einigen Themen experimentierfreudig. Da geht es nicht immer darum, ob es auch einfacher geht, sondern darum ob ich die Zusammenhänge verstanden habe oder in der Lage bin ein gegebenes Problem mit eigenen Mitteln zu lösen.

Ich verstehe den Anwendungsfall nicht. Was willst Du erreichen?

Dakuan schrieb:

Es geht darum, dass ein normaler Benutzer einfach einen Server, in einem bestimmten Verzeichnis, starten kann und damit eine Freigabe erstellt, die mit Beendigung des Servers zurückgezogen ist.

Um was für eine Freigabe soll es sich denn handeln? Und was soll das für ein Server sein?

Der Grund für diese Vorgehensweise ist, dass der Server Zugriff auf die lokalen und individualisierten (durch ein anderes Programm erzeugten) Vorschaudateien und den darin möglicherweise enthaltenen Metadaten haben soll.

Mit "die Vorgehensweise" meinst Du, dass beliebige Nutzer das Programm in ihren eigenen Verzeichnissen starten können sollen, weil der Server so die passenden Zugriffsrechte besitzt.

Das bekomme ich mit "normalen" Servern und PHP nicht hin, da diese unter einem eigenen Benutzernamen laufen und damit keinen Zugriff auf sensible Daten des Benutzers (Thumbnails) keinen Zugriff haben.

Das sollte sich mit ein wenig Scripting um den Serveraufruf herum hinbekommen lassen. Ansonsten kann man so etwas total billig mit WEBrick machen. Das grenzt an einen Einzeiler für einen HTTP-Server.

Das Problem entsteht jetzt dadurch, dass in der erzeugten Web-Site die kompletten Pfade nicht sichtbar sein sollen. Es sollen nur Namen unterhalb des freigegebenen Verzeichnisses sichtbar sein.

Das sollte sehr einfach sein mit WEBrick.

Das bedeutet, das der Server den Clients u.a. einige (konstante) Variablen (gr) bereitstellen muss. Als da sind:

• home_dir

• cache_dir

• thumb_base_dir

• thumb_sub_dir

Wieso das? Wie sollen die Variablen von wem and wen übergeben werden? Oder meinst Du, es muss Requests mit diesen Namen geben, die spezielle Daten liefern?

Das ist notwendig, damit die Angaben aus der generierten HTML Seite serverseitig so ergänzt werden können, dass eine Funktionalität gegeben ist.

Jetzt wird eine HTML-Seite generiert. Äh...

Die Frage ist jetzt, ob das ohne den Einsatz von Shared-Memory / Maped-Memory (mmap hatte ich schon verwendet) möglich ist. Mein Englisch ist jetzt nicht so gut, dass ich aus den Dokumentationen sicher herauslesen könnte, dass ein rein lesender Zugriff ohne weiteres möglich wäre. Wenn das ginge, wäre das eine deutliche Vereinvachung. Bei mmap() müsste ich ja auch die Größe des Datenblocks angeben, der ja nicht unbedingt bekannt sein muss.

An keiner Stelle in Deinem Posting erwähnst Du den fork(), der im Titel steht. Welche Rolle spielt der nun wieder?

@Dakuan leider verstehe ich noch immer nicht dein Ziel. Wenn du schon was programmiert hast, bitte mal deinen kompletten Code in einem codeblock, vielleicht verstehen wir danach dein Problem, mit den bisher gegebenen Informationen habe ich einfach zu viele Fragezeichen

Um was für eine Freigabe soll es sich denn handeln?

Ich will einfach mal, vorübergehend und ohne große Vorbereitung, hauptsächlich Video Dateien freigeben. Die sollen dann hauptsächlich auf dem Tablet zu sehen sein.

Die Komplikation dabei ist, dass ich die Vorschaubilder, die im System bereits vorhanden sind, dafür verwenden will.

Bei den Pfaden war ich etwas zu schnell mit dem Kopieren. Benötigt wird das Basisverzeichnis für die Vorschaudateien, welches durch die Umgsbungsvariable XDG_CACHE_HOME verändert sein könnte, und mindestens das Arbeitsverzeichnis. Ich wollte vermeiden, dass bei jeder GET Anfrage diese Werte jedesmal von Kindprozess ermittelt werden müssen.

WEBrick sieht gut aus, aber ich sehe momentan nicht, wie ich da ein C-Programm einbauen kann. Ich sehe mich momentan nicht in der Lage, per Script, für einen Pfad eine URL-Codierung zu erzeugen und davon dann die MD5 Summe zu bilden. Das braucht man um den Namen der Vorschaudateien zu ermitteln.

Im erzeugten HTML Dokument soll nur der Basisname der Vorschaudatei stehen. Daraus muss dann z.B.

/home/<username>/.cache/thumbnails/large/08bc22d04790c81efb38496a322e64ee.png

gemacht werden.

Wenn du schon was programmiert hast, bitte mal deinen kompletten Code in einem codeblock, ...

Bist du sicher dass ich das darf? Das ist ein anderes Projekt mit ca. 3000 Zeilen (ohne Header) von dem ich vieles wieder verwenden will. Ich fange mal mit dem Grundbaustein an. Man achte da auf worker_init() wo die Pfade ermittelt werden:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

//-----------------------------------------------------------------------------
//      thumbsv.c
//      ...
//  Start the server wit the following command:
//  thumbsv [server option(s)]  [-- [-v 1] [-d 1]]
//      -p portnum  the port you want the server to listen - default is 8080
//      -i IP-vers  0 = unspec (default), 4 = IPv4, 6 = IPv6
//      --          this is to separate the options for the server worker from
//                  the server core options.
//      -v #        verbosity currently only 0 or 1 - default is 0
//      -d #        enable debug messages (1 - 2)
//
#define _DEFAULT_SOURCE     // To get NI_MAXHOST and NI_MAXSERV from <netdb.h>
#include <netdb.h>

#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>       // waitpid()
#include <sys/types.h>      // gai_strerror() - debug
#include <signal.h>
#include <errno.h>
#include <stdlib.h>         // exit()
#include <stdio.h>
#include <string.h>         // memset()

#include "ts_child.h"       // worker_...

#define BACKLOG 5

static void
sigchldHandler( int sig ) {
    int savedErrno = errno;
    while( waitpid( -1, NULL, WNOHANG ) > 0 )
        continue;
    errno = savedErrno;
}

//-----------------------------------------------------------------------------
//
int
main( int argc, char *argv[] ) {
    struct sigaction sa;
    int             c;
    int             s;
    int             tmp;
    char            port_num[8] = "8080";
    const char *    protocol[] = { "unspecified", "IPv4", "IPv6" };
    const char *    p;
    int             ai_family = AF_UNSPEC; // IPv4 or IPv6, maybe changed
    struct sockaddr_storage claddr;
    int             pfd, cfd, optval;
    socklen_t       addrlen;
    struct addrinfo hints;
    struct addrinfo *result, *rp;
    #define ADDRSTRLEN (NI_MAXHOST+NI_MAXSERV+10)
    char            addrStr[ADDRSTRLEN];
    char            host[NI_MAXHOST];
    char            service[NI_MAXSERV];

    if( argc > 1 ) {
        while ((c = getopt( argc, argv, "p:i:" )) != -1) {
            switch( c ) {
                case 'p':   snprintf( port_num, sizeof(port_num), "%s", optarg );
                    break;

                case 'i':
                    switch( (tmp = atoi( optarg )) ) {
                        case 0:     ai_family = AF_UNSPEC;  break;
                        case 4:     ai_family = AF_INET;    break;
                        case 6:     ai_family = AF_INET6;   break;
                    }
                    break;
            }
        }
    }
    worker_init( argc, argv );  //<<<< Im Kind Modul
    sigemptyset( &sa.sa_mask );
    sa.sa_flags = SA_RESTART;
    sa.sa_handler = sigchldHandler;
    if( sigaction( SIGCHLD, &sa, NULL) == -1 ) {
        perror( "sigaction" );
        exit( EXIT_FAILURE );
    }
    // get a lst of possible addresses
    memset( &hints, 0, sizeof( hints ) );
    hints.ai_flags     = AI_PASSIVE | AI_NUMERICSERV;
    hints.ai_family    = ai_family;
    hints.ai_socktype  = SOCK_STREAM;
    hints.ai_protocol  = IPPROTO_TCP;
    hints.ai_canonname = NULL;
    hints.ai_addr      = NULL;
    hints.ai_next      = NULL;
    if( (s = getaddrinfo( NULL, port_num, &hints, &result )) != 0 ) {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(s));
        exit( EXIT_FAILURE );
    }

    // Walk through returned list until we find an address structure
    // that can be used to successfully create and bind a socket
    optval = 1;     // SO_REUSEADDR = true
    for( rp = result; rp != NULL; rp = rp->ai_next ) {
        if( (pfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol)) == -1 )
            continue;
        if( setsockopt( pfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval) ) == -1 ) {
            perror( "setsockopt" );
            exit( EXIT_FAILURE );
        }
        if( bind( pfd, rp->ai_addr, rp->ai_addrlen ) == 0 ) {
            ai_family = rp->ai_family;
            break;      // -> OK
        }
        close( pfd );
    }
    if( rp == NULL ) {
        perror( "Could not bind socket to any address" );
        exit( EXIT_FAILURE );
    }
    if( listen( pfd, BACKLOG ) == -1 ) {
        perror( "listen" );
        exit( EXIT_FAILURE );
    }
    freeaddrinfo( result );
    switch( ai_family ) {
        case AF_INET:   p = protocol[1];    break;
        case AF_INET6:  p = protocol[2];    break;
        default:        p = protocol[0];    break;
    }
    printf( "Listening on port: %s protocol: %s\n", port_num, p );
    addrlen = sizeof(struct sockaddr_storage);
    for( ;; ) {
        cfd = accept( pfd, (struct sockaddr *) &claddr, &addrlen );
        if( cfd == -1 ) {
            perror( "accept" );
            continue;
        }

        // (debug) info - to be removed later ?
        if( getnameinfo( (struct sockaddr *) &claddr, addrlen,
                    host, NI_MAXHOST, service, NI_MAXSERV, 0 ) == 0 )
            snprintf( addrStr, ADDRSTRLEN, "(%s, %s)", host, service );
        else
            snprintf( addrStr, ADDRSTRLEN, "(?UNKNOWN?)" );
        printf( "Connection from %s\n", addrStr );

        switch( fork() ) {
        case -1:
            printf( "Can't create child (%s)", strerror(errno) );
            close( cfd );
            break;

        case 0:                         // child
            close( pfd );               // close unneeded copy of listening socket
            httpd( cfd );       // <<<<
            _exit( EXIT_SUCCESS );

        default:                        // parent
            close( cfd );               // close unneeded copy of connected socket
            break;
        }
    }
    worker_uninit();
}

Bei dem Beispiel habe ich allerdings mmap() verwendet. Da dürfen dann aber keine Zeiger enthalten sein.

PS: Ich habe wohl komplett auf dem Schlauch gastanden, auch damals schon. Ich war der Meinung dass ich irgendwo ein exec...() drinn hatte, was aber nicht der Fall ist. Somit erben die Kindprozesse alles, wie seahawk1986 schon angemerkt hatte. Damit können wir das Thema hier beenden.

Ok, mir war nicht klar das es sich um C handelt, da bin ich raus. Ich persönlich hätte es vermutlich in python3 geschrieben oder einfach wie ich es jetzt mache mit einem WebDAV Server (meine Videos schaue ich mit Infuse auf dem Apple TV, iPad, iPhone

Dakuan schrieb:

Um was für eine Freigabe soll es sich denn handeln?

Bitte lass die Zitatreferenz drinnen! Da wird nicht umsonst Name und Link generiert.

Ich will einfach mal, vorübergehend und ohne große Vorbereitung, hauptsächlich Video Dateien freigeben. Die sollen dann hauptsächlich auf dem Tablet zu sehen sein.

Das war nicht die Frage. Was für eine Freigabe soll das werden? Ist das HTTP, NFS, SMB, etwas Proprietäres?

Die Komplikation dabei ist, dass ich die Vorschaubilder, die im System bereits vorhanden sind, dafür verwenden will.

Du erwähnst neue Begriffe, ohne dass ich einen Zusammenhang erkennen könnte. Ich verstehe nicht, wozu das ganze gut sein soll und was Du vorhast. Mir kommt es so vor, dass Du schon recht tief in die Implementierung abgetaucht bist und deshalb über solche Details schreibst. Das hilft aber mir zumindest nicht, zu verstehen, worum es geht. Ich such eher nach einem Use Case oder meinetwegen Anforderungen oder Szenarios.

So richtig verstehe ich das Ziel bzw. die Anwendung auch nicht. Klingt aber irgendwie nach einem Anwendungsfall für einen Instant Webserver.

micneu schrieb:

PS: bei über 6000 Beiträge hier im Forum musst du doch schon ein Profi in Sachen Ubuntu sein?

Das hat doch nichts miteinander zu tun? "Ubuntu Profi" und "Programmierprofi" geht nicht einher.

Klingt aber irgendwie nach einem Anwendungsfall für einen Instant Webserver.

Genau das ist es! Allerdings muss die Webseite erst noch erstellt werden. Das könnte ich natürlich extern machen aber ich möchte, dass der Server die Verzeichnisinhalte nicht verändert. Das soll also alles "on the fly" passieren.

@rklm Ich habe tatsächlich viele der benötigten Bausteine seit einiger Zeit fertig und verwende sie in mehreren anderen Programmen.

Hier noch ein Hinweis zu meinem Denkfehler. Ich habe zuletzt an einer Programmsammlung gebastelt, wo die Programme unter anderem ffmpeg und ffprobe gestartet hatten und deren Ausgaben auswerten. Und wegen einiger problematischer Dateinamen will ich dafür nicht system() verwenden. Da habe ich immer fork() mit execvp() eingesetzt. Nach exec..() hat man kein Zugriff auf die geerbten Daten, das hat sich bei mir irgendwie fest gesetzt. Sorry. Eigentlich gehört dieser Thread gelöscht.