HTTP szervert keresek

https://static-web-server.net/ esetleg?

uhttpd nem jo? openwrt-n/routeren az mukodik.

vagy esp32-n mi fut? pl. shelly wifis rele-ben is van webszerver.

Mi a feladat pontosan? A storage a szűk keresztmetszet, a számítási kapacitás, stb.?

lighttpd?

https://tools.suckless.org/quark/

Nem ez volt?

itt van felsorolva pár minimál megoldás
https://gist.github.com/willurd/5720255

Azért 100 sorban gyanúsan nem szerver, hanem max valami hello world szintű vagy máshonnal libet használó dolog lehet, mint pl ez. Biztos, hogy c volt?
https://www.perlmonks.org/?node_id=116767

Bár C-ben pico webszerver
https://github.com/foxweb/pico
azt írja, egy 2010-es, nem elérhető helyre mutató linkes dolog volt az alapja

Lehet, hogy nem erre gondoltál, de ez azt tudja amit leírtál: "redbean is an open source webserver in a zip executable that runs on six operating systems"

https://redbean.dev/

Egyébként én ezeket használnám, ha nem egy openwrt szintű embedded rendszerről van szó: caddy, algernon. Ha minimál gépigény a cél, akkor busybox (httpd), uhttpd, darkhttpd, miniserve, lighttpd, esetleg nginx.

https://en.wikipedia.org/wiki/TUX_web_server

Annó a főnököm is írt egy minimál webszervert:

#include <stdio.h>
#include <stdlib.h>
#include <syslog.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fnmatch.h>
#include <libgen.h>

/*#define DEBUG*/

#define PORT 80
#define DOCUMENTROOT "/home/httpd/html"

char            request_file[1024];
void            *memory_buffer;
size_t  buffer_size;
int                     sock;

void hiba( const char *hiba ){
        syslog( 0, hiba );
        exit(1);
}/*hiba*/

int loadfile( ){
struct stat     size;
int                                     infile;

        if( stat( request_file, &size ) != 0 )
                hiba( "File not found.\n" );

        buffer_size = size.st_size;
        
        memory_buffer=malloc( buffer_size );
        if( memory_buffer==NULL )
                hiba( "Out of memory.\n" );

        infile=open( request_file, O_RDONLY );
        if( read( infile, memory_buffer, buffer_size ) != buffer_size )
                hiba( "Unable to read file." );

        close( infile );
}/*sendfile*/

int kapu_nyitasa( void ){
int                 kapu;
struct sockaddr_in  barki;

        kapu = socket (PF_INET, SOCK_STREAM, 0);
        if(kapu < 0)
                hiba( "Error open socket.\n" );

        barki.sin_family=AF_INET;
        barki.sin_port=htons(PORT);
        barki.sin_addr.s_addr=htonl(INADDR_ANY);
        if(bind(kapu, (struct sockaddr *) &barki, sizeof(barki)) < 0)
                hiba( "Error binding socket.\n" );
        
  return kapu;
}/*kapu_nyitasa*/


int olvasas( int kapu ){
char    memoria[1024];
int     n;
        sprintf( request_file, DOCUMENTROOT );

        n=read(kapu, memoria, 1024);
        if( n < 0 )
                hiba( "Error reading socket.\n" );

        sscanf(memoria, "GET %s", 
                        &request_file[strlen(DOCUMENTROOT)] );
        

        if( request_file[strlen(request_file)-1]=='/' )
                        sprintf(&request_file[strlen(request_file)], "index.html" );
        
        #ifdef DEBUG
        syslog( 0, "File request: %s\n", request_file );
        #endif

        return( n );
}/*olvasas*/
        

int iras( int kapu ){
char head_template[]="HTTP/1.0 200 OK\r\n\
Server: miniserver/0.1\r\n\
Connection: close\r\n\
Content-Type: %s\r\n\r\n";
char    head[512];
char  *type;
int             irt;

        type="text/html";
        if( fnmatch("*.gif", basename(request_file), 0) == 0 )
                type="image/gif";
        if( fnmatch("*.jpg", basename(request_file), 0) == 0 )
                type="image/jpeg";
        if( fnmatch("*.png", basename(request_file), 0) == 0 )
                type="image/png";
        
        sprintf( head, head_template, type ); 

        irt=write( kapu, head, strlen(head));
        
        if( memory_buffer != NULL )
                irt=write( kapu, memory_buffer, buffer_size );
        else
                syslog( 0, "Error: no data to send.\n" );
 
        return(1);
}/*iras*/


int  mainloop( void ){
int new;
int i;
struct sockaddr_in clientname;
size_t size;

        sock=kapu_nyitasa();
        while( 1 ){
                if( listen (sock, 1) < 0 )
                        hiba( "Error while listening." );

                        size = sizeof (clientname);
                        new = accept(sock, (struct sockaddr *) &clientname, &size);

                        /*waitpid( WAIT_ANY, NULL, WNOHANG );*/
                        if( fork() != 0 ){
                                olvasas( new );
                                loadfile();
                                iras( new );
                                shutdown( new, 2 );
                                if( memory_buffer != NULL )
                                        free(memory_buffer);
                                return(0);
                        }
        }/*while*/
}/*mainloop*/
 
void signal_handler( int signal ){
        shutdown( sock, 2 );
        hiba("Exiting...\n");
}/*signal_handler*/     


int main( int argc, char *argv[] ){
        openlog( "webserver", LOG_PID, LOG_MAKEPRI(LOG_DAEMON, LOG_DEBUG) );
        syslog( 0, "Miniserver started." );
        
        signal( SIGINT, signal_handler );
        signal( SIGKILL, signal_handler );
        signal( SIGTERM, signal_handler );
        
        daemon( 0, 0 );
  mainloop();   
        return(0);
}/*main*/

Bár ahogy nézem egy mai gcc már eléggé panaszkodik rá...

egy "#include <string.h>" hozzátétele után viszont azért fordul, és még ki is szolgál fájlokat, persze a 404 már gondot okoz neki (2002 tájéka volt talán, demonstrációs céllal írta, én is azzal osztom itt meg csupán)