Writing web applications in C is a great idea. Still, people who want to write their own app using C can't legally do it without opening their sources. That's because you distribute it under GPL terms as a set of source files which should be extended by users to get their functionality:

2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:

    a) You must cause the modified files to carry prominent notices
    stating that you changed the files and the date of any change.

    b) You must cause any work that you distribute or publish, that in
    whole or in part contains or is derived from the Program or any
    part thereof, to be licensed as a whole at no charge to all third
    parties under the terms of this License.

    c) If the modified program normally reads commands interactively
    when run, you must cause it, when started running for such
    interactive use in the most ordinary way, to print or display an
    announcement including an appropriate copyright notice and a
    notice that there is no warranty (or else, saying that you provide
    a warranty) and that users may redistribute the program under
    these conditions, and telling the user how to view a copy of this
    License.  (Exception: if the Program itself is interactive but
    does not normally print such an announcement, your work based 

It would be more appropriate to license it under dual MIT/GPL license so people could use your framework without opening the application source code.

an alternative solution might be

void server(Request request)
{
    int is_404 = 0;
    is_404 |= nope_route(request, "/factor", &factor, true);
    is_404 |= something else...
    if(!is_404)
    {
        handler_404(request);
    }
}

void handler_404(Request request)
{
    not_found(request.client);
}

resolve memory leak due to duplicating strings and not freeing them.

Also replaced dupstr() with strdup()

Actually using a static buffer in the calling function would probably be even better

This pull request actually implements several different changes I made.

The first, and simplest, is moving the source code files and headers into the src/ directory and object files into the obj/ directory.

The second allows to parse data from the POST requests as the request's "contentData".

The last one implements caching and Last-Modified header support for the serveFile() function.

If accepting such a pull request is too difficult, I may split it into several if so necessary.

Wrote a small service to serve static content using this method. Closing the write handle here leads to double close bugs later on. It's unnecessary given the wrapping framework.

malloc(n * size) is an antipattern as n * size can overflow (especially from an attacker). You'll want to use calloc or create your own malloc_array function. Something like the following could work:

static inline void * malloc_array(size_t nmemb, size_t size)
{
    /* Make the check so that a constant size deletes the zero check
     * and the division.
     */
    if (size != 0u && SIZE_MAX / size < nmemb) {
        errno = ENOMEM;
        return NULL;
    }

    return malloc(size * nmemb);
}

Perhaps not an issue, may be my short sightedness. Is there any way to set the mimetype of the response. I would like to use nope.c to produce small rest servers serving simple dynamic json. i would like to be able to set response mimetype as "application/json", based on the response.

Made makefile look slightly better, building nope.c as a static library (libnope.a), and added the ability to have multiple samples (variable "MODULES" in the makefile) compiled. Additionally if you develop your own module (ex. foobar.c) in nope.c's main directory, you can then type "make foobar" to get your source compiled against nope.c.

Also removed -pthread parameter since only fork() is being used (ie. no threads right now).

Finally fixed some warnings in nope.c and nopeutils.c

Would you like to add more error handling for return values from functions like the following?

• pthread_mutex_init ⇒ initialize_threads
• strdup ⇒ getQueryPath

WAFer is: ultra-light ... wafer-thin

Can you be more specific in the README? We would like to see approximate LOC, size in memory, size on disk. (compared with node.js etc.)

notify_parent() is not used in your curent version and timespec is not used too. Could you clean this up? The way you called getnameinfo without checking its failure mode is a bit confusing to me.

I was a bit confused while going through your code particularly when I noticed that socket used "AF-Unix" . Why using it? I also noticed that now you have epoll, thread, and select. I fcntl and thread, but what do you again with epoll

I carried out a load test for nope example.

./wrk -t1 -c1 -d10s http://localhost:4242/factor

The config is: NOPE_EPOLL, NOPE_THREAD 2 The bug looks like this:

GET /factorGET /factorGET /factorGET /factorGET /factorGET /factorGET /factorGET /factorGET .... /factorGET /factorGEclose: Bad file descriptor