The BSD standard provides some goodies in err.h. If the header is available on your system, you may be able to replace your custom error() function with BSD's err() (or some other version thereof).

That being said, the argument to error() should be of type const char * as it is not modified anywhere in the function.

bzero(*reply, 18);

From Linux's man page of bcopy():

Marked as LEGACY in POSIX.1-2001: use memcpy(3) or memmove(3) in new programs. Note that the first two arguments are interchanged for memcpy(3) and memmove(3). POSIX.1-2008 removes the specification of bcopy().

In other words, replace it with memcpy()/memmove().

The name get_file() appears rather ambiguous. I also do not understand what these magic values:

int end, start, i;
end = 4;
start = 4;
i = 4;

mean. Furthermore, the return value of malloc() goes unchecked in the function. In case of an error, malloc() returns a null pointer. Failure to check for it risks invoking undefined behavior by a subsequent null pointer dereference. The call to memcpy() following malloc() technically invokes undefined behavior too, because file might be NULL, and the C standard 7.1.4 states:

If an argument to a function has an invalid value (such as a value outside the domain of the function, or a pointer outside the address space of the program, or a null pointer, or a pointer to non-modifiable storage when the corresponding parameter is not const-qualified) or a type (after promotion) not expected by a function with variable number of arguments, the behavior is undefined.

Here too the passed in char * is not modified, so this should be declared with the const qualifier too.

void handle_sigint(int sig)
{
    exit(-1);
    printf("Server setting down\n");
}

is plain undefined behavior.

According to §7.14.2.1:

If the signal occurs other than as the result of calling the abort or raise function, the behavior is undefined if the signal handler refers to any object with static or thread storage duration that is not a lock-free atomic object other than by assigning a value to an object declared as volatile sig_atomic_t, or the signal handler calls any function in the standard library other than — the abort function, — the _Exit function, — the quick_exit function, — the functions in <stdatomic.h> (except where explicitly stated otherwise) when the atomic arguments are lock-free, — the atomic_is_lock_free function with any atomic argument, or — the signal function with the first argument equal to the signal number corresponding to the signal that caused the invocation of the handler. Furthermore, if such a call to the signal function results in a SIG_ERR return, the value of errno is indeterminate.

These functions are async-signal-unsafe even in the POSIX standard. As alternatives, the POSIX standard does specify that _exit(), _Exit(), and write() are safe to be called in a signal handler.

But how do you report an error if write() fails and there's no other possible way to report an error? You don't.

But really, you shouldn't be using signal() in the first place. According to Linux's man page:

WARNING: the behavior of signal() varies across UNIX versions, and has also varied historically across different versions of Linux. Avoid its use: use sigaction(2) instead.

I do not see why printing "Server setting down\n" on a SIGINT is necessary, or even useful. It is only serving to introduce more complexity in the code. And then you're exiting with an error status of -1 - which is another magic value - instead of EXIT_FAILURE from stdlib.h.

Ideally, the signal handler should only set a file-scope flag variable of type volatile sig_atomic_t which would be checked in main() before each iteration.

Though, you should disable SIGHUP because a closed connection would generate a send/recv error, which would kill the server process.

For which signal() suffices, as the man page says:

The only portable use of signal() is to set a signal's disposition to SIG_DFL or SIG_IGN.

Here's another problematic part of the code:

portno = htons(atoi(argv[1]));

Ignoring what the man page of atoi() says in the BUGS portion, we're accessing argv[1] without checking whether argc was greater than 1. Your program calls htons(atoi(argv[1])) with a null pointer when I run it without providing any arguments, so this too is undefined behavior.

You are exiting if bind() fails, and leaking the sockfd file descriptor.

The return value of listen() is ignored. Execution should not continue if listen() failed.

 char public_dir[256] = "./public";
 if (strcmp(file, "/") == 0)
 {
     fptr = fopen("./public/index.html", "r");

Consider defining macros for these strings so that they can be edited easily and in one place.

In read_file_to_buffer(), the return value of malloc() and fread() goes unchecked. Consider using true and false from stdbool.h instead of 0 and -1 for the return value.

In main(), fail_message should be of type const char *.

I doubt it matters much if we failed to close the server socket before exiting the program.

I would have expected to see send()/recv() in networking code rather than read()/write().

Calling exit() in the child branch of a fork() is a good way of
calling the functions registered with atexit(), flushing stdio buffers, deleting temporary files created with tmpfile() et cetera. Why use _exit rather than exit in the child branch of a fork?

In process_response(), the return value of strchr() goes unchecked. It may very well return a null pointer, dereferencing which would later invoke undefined behavior.

Then we have another magic value:

int lent = 18;
*reply = (char *)malloc(18);
bzero(*reply, 18);

This too holds no meaning to me. What is 18, and what does it denote?

The return value of malloc() goes unused here as well. There's also a needless cast. Starting with C89 (which is a 35 year old standard) malloc() and family returns a generic void * that is implicitly converted to and from any other pointer type. As such, its result need not be casted and only serves to clutter the code.

Then we have a lot of duplicate code. I'd refactor that into, perhaps, a table and pre-compute the lengths of the content-type headers.

realloc() is used incorrectly in the code. The return value should not be stored in the same pointer that is being reallocated. If realloc() fails, which you don't check for by ignoring the return value, it would return a null pointer which would overwrite the pointer to the original chunk of memory, and we'd have a memory leak in the code, and on subsequent requests, more memory leaks.

There's a BUFFER_LENGTH in main() whose definition I do not see in any part of the code.

*(request + i) is typically written as request[i].

main() is too long and does too much. Break it into smaller functions.