Практическое задание

bool parse(const char* line, char* abs_path, char* query)
{
    int len = strlen(line);
    char *buf;

    int countSpaces = 0;
    int countQues = 0;
    for (int i = 0; i < len; i++){
        if (line[i] == ' ')
            countSpaces++;
        if (line[i] == '?')
            countQues++;
    }
    if (countSpaces != 2 || countQues > 1){
        error(400);
        return false;
    }

    buf = strstr(line, " /");
    if (buf == NULL){
        error(501);
        return false;
    }
    buf = strchr(line, '/');

    for (int i = 0; i < len; i++){
        if (buf[i] == '?' || buf[i] == ' '){
            abs_path[i] = '\0';
            break;
        }else
            abs_path[i] = buf[i];
    }

    if (!strchr(abs_path, '.')){
        error(501);
        return false;
    }

    const char *httpQuery = strchr(line, '?');

    if(httpQuery != NULL && !strstr(line, "? ")){
        for (int i = 0; i < strlen(httpQuery); i++){
            if (httpQuery[i] == ' '){
                strncpy(query, httpQuery, i);
                break;
            }
        }

        int lenQuery = strlen(query);
        for (int i = 0; i < lenQuery; i++){
            if (i == lenQuery-1){
                query[i] = '\0';
            }else{
                query[i] = query[i+1];
            }
        }
    }else{
        query[0] = '\0';
    }

    if (!strstr(line, "GET")){
        error(405);
        return false;
    }
    if (strchr(abs_path, '"')){
        error(400);
        return false;
    }
    if (!strstr(line, "HTTP/1.1")){
        error(505);
        return false;
    }

    error(501);

    return false;
}

char* indexes(const char* path)
{
    char *fileNames[] = {"index.php", "index.html"};

    for (int i = 0; i < 2; i++){
        char *absPath = malloc(strlen(path) + strlen(fileNames[i]) + 1);
        absPath[0] = '\0';

        strcat(absPath, path);
        strcat(absPath, fileNames[i]);

        if (access(absPath, F_OK) == 0){
            return absPath;
        }
        free(absPath);
    }

    return NULL;
}

            // ивзлечь request-line из запроса
            // http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html
            const char* haystack = request; //передать haystack адрес, который хранится в request
            char* needle = strstr(haystack, "\r\n"); //найти CRLF (\r\n) в запросе и присвоить его адрес needle (о strstr информацию найти нетрудно)
            if (needle == NULL)
            {
                error(400);
                continue;
            }
            else if (needle - haystack + 2 > LimitRequestLine) //вспоминаем про арифметику на указателях
            {
                error(414);
                continue;
            }
            char line[needle - haystack + 2 + 1]; //формула: [длина строки (внутри запроса) от начала до \r\n + \r\n + \0]
            strncpy(line, haystack, needle - haystack + 2); //перенести все содержимое от начала строки запроса до \r\n в строку (массив символов) line.
            line[needle - haystack + 2] = '\0';

http-server -p 8080

/**
 * Checks, in order, whether index.php or index.html exists inside of path.
 * Returns path to first match if so, else NULL.
 */
char *indexes(const char *path)
{
    static const char *indexlist[] = {"index.php", "index.html"};
    char *indexfile = NULL;

    for (int i = 0; i < sizeof(indexlist) / sizeof(*indexlist); i++) {
        indexfile = malloc(strlen(path) + strlen(indexlist[i]) + 1);
        if (!indexfile)
            return NULL;

        strcpy(indexfile, path);
        strcat(indexfile, indexlist[i]);

        if (!access(indexfile, F_OK))
            return indexfile;
        
        free(indexfile);
    }

    return NULL;
}

/**
 * Loads a file into memory dynamically allocated on heap.
 * Stores address thereof in *content and length thereof in *length.
 */
bool load(FILE *file, BYTE **content, size_t *length)
{
    BYTE buffer[BYTES];
    size_t readblocks;
    *length = 0;
    *content = malloc(1);

    while (!feof(file)) {
        readblocks = fread(buffer, sizeof(BYTE), BYTES, file);
        *length += readblocks;
        *content = realloc(*content, *length);
        if (!*content)
            return false;
        memcpy(*content + *length - readblocks, buffer, readblocks);
    }

    return true;
}

/**
 * Returns MIME type for supported extensions, else NULL.
 */
const char *lookup(const char *path)
{
    static const char *extlist[] =  {".css", ".html", ".gif", ".ico", ".jpg", ".js", ".php", ".png"};
    static const char *MIMElist[] =
    {
        "text/css",
        "text/html",
        "image/gif",
        "image/x-icon",
        "image/jpeg",
        "text/javascript",
        "text/x-php",
        "image/png"
    };

    char *pathext = strrchr(path, '.');
    for (int i = 0; pathext[i]; pathext[i] = tolower(pathext[i]), i++) {}

    for (int i = 0; i < sizeof(extlist) / sizeof(*extlist); i++)
        if (!strcmp(extlist[i], pathext))
            return MIMElist[i];

    return NULL;
}

/**
 * Parses a request-line, storing its absolute-path at abs_path
 * and its query string at query, both of which are assumed
 * to be at least of length LimitRequestLine + 1.
 */
bool parse(const char *line, char *abs_path, char *query)
{
    if (strncmp("GET ", line, 4)) {
        error(405);
        return false;
    }

    if (strcmp(" HTTP/1.1\r\n", strrchr(line, ' '))) {
        error(505);
        return false;
    }

    strcpy(abs_path, strchr(line, ' ') + 1);
    *strrchr(abs_path, ' ') = '\0';

    if (abs_path[0] != '/') {
        error(501);
        return false;
    }

    if (strchr(abs_path, ' ') || strchr(abs_path, '"')) {
        error(400);
        return false;
    }

    if (strchr(abs_path, '?')) {
        strcpy(query, strchr(abs_path, '?') + 1);
        *strchr(abs_path, '?') = '\0';
    }

    return true;
}