HTTP Request Parser - Problem

Parse a raw HTTP request string into a structured object containing the request method, path, headers, query parameters, and body.

An HTTP request has the following format:

Request Line: METHOD /path?query HTTP/1.1
Headers: Header-Name: Header-Value (one per line)
Empty Line: Separates headers from body
Body: Optional request body content

Return an object with fields: method, path, query (as object), headers (as object), and body.

Input & Output

Example 1 — GET Request with Query Parameters

$ Input: GET /users?id=123&name=john HTTP/1.1\nHost: api.example.com\nContent-Type: application/json\n\n{"data": "test"}

› Output: {"method":"GET","path":"/users","query":{"id":"123","name":"john"},"headers":{"Host":"api.example.com","Content-Type":"application/json"},"body":"{\"data\": \"test\"}"}

💡 Note: Parses GET request with query parameters id=123&name=john, extracts headers, and captures JSON body

Example 2 — POST Request without Query

$ Input: POST /api/users HTTP/1.1\nAuthorization: Bearer token123\n\n{"name":"Alice","age":25}

› Output: {"method":"POST","path":"/api/users","query":{},"headers":{"Authorization":"Bearer token123"},"body":"{\"name\":\"Alice\",\"age\":25}"}

💡 Note: POST request to /api/users with Authorization header and JSON body containing user data

Example 3 — Simple GET without Body

$ Input: GET /health HTTP/1.1\nUser-Agent: Mozilla/5.0\n\n

› Output: {"method":"GET","path":"/health","query":{},"headers":{"User-Agent":"Mozilla/5.0"},"body":""}

💡 Note: Simple health check request with no query parameters and empty body

Constraints

1 ≤ rawRequest.length ≤ 10⁴
HTTP method is one of: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
Path starts with '/' character
Headers follow 'Key: Value' format
Empty line separates headers from body

Visualization

Tap to expand

Asked in

G Google 42 a Amazon 38 M Microsoft 35 N Netflix 28

The key insight is recognizing that HTTP requests follow a structured format that can be parsed efficiently using a state machine. The optimal approach processes the request line-by-line in a single pass, transitioning between REQUEST_LINE → HEADERS → BODY states. Time: O(n), Space: O(n).

Common Approaches

✓ Character-by-Character Scanning

⏱️ Time: O(n²) Space: O(n)

Process the raw HTTP string character by character, identifying different components through pattern matching and string operations. Parse each section individually without leveraging the known HTTP structure.

Line-by-Line State Machine

⏱️ Time: O(n) Space: O(n)

Use a state machine to parse the HTTP request efficiently. Process each line once, identifying the current section (request line, headers, body) and parsing accordingly.

Character-by-Character Scanning — Algorithm Steps

Scan character by character to find request line
Search for headers by looking for colon separators
Find empty line by detecting double newlines
Extract remaining content as body

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan Request Line

Process each character to find method and path

Find Headers

Look for colon separators in each line

Extract Body

Take remaining content after empty line

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cjson/cJSON.h>

cJSON* solution(const char* rawRequest) {
    cJSON *result = cJSON_CreateObject();
    cJSON *method = cJSON_CreateString("");
    cJSON *path = cJSON_CreateString("");
    cJSON *query = cJSON_CreateObject();
    cJSON *headers = cJSON_CreateObject();
    cJSON *body = cJSON_CreateString("");
    
    cJSON_AddItemToObject(result, "method", method);
    cJSON_AddItemToObject(result, "path", path);
    cJSON_AddItemToObject(result, "query", query);
    cJSON_AddItemToObject(result, "headers", headers);
    cJSON_AddItemToObject(result, "body", body);
    
    char *lines[1000];
    int lineCount = 0;
    char *copy = strdup(rawRequest);
    char *line = strtok(copy, "\n");
    while (line != NULL && lineCount < 1000) {
        lines[lineCount++] = strdup(line);
        line = strtok(NULL, "\n");
    }
    
    if (lineCount == 0) {
        free(copy);
        return result;
    }
    
    // Parse request line character by character
    char *requestLine = lines[0];
    char parts[10][256];
    int partCount = 0;
    int partIdx = 0;
    for (int i = 0; i < strlen(requestLine) && partCount < 10; i++) {
        if (requestLine[i] == ' ') {
            if (partIdx > 0) {
                parts[partCount][partIdx] = '\0';
                partCount++;
                partIdx = 0;
            }
        } else {
            parts[partCount][partIdx++] = requestLine[i];
        }
    }
    if (partIdx > 0) {
        parts[partCount][partIdx] = '\0';
        partCount++;
    }
    
    if (partCount >= 2) {
        cJSON_SetValuestring(method, parts[0]);
        
        // Parse URL character by character
        char path_str[512] = "";
        char query_str[512] = "";
        int foundQuery = 0;
        int pathIdx = 0, queryIdx = 0;
        for (int i = 0; i < strlen(parts[1]); i++) {
            if (parts[1][i] == '?') {
                foundQuery = 1;
            } else if (foundQuery) {
                query_str[queryIdx++] = parts[1][i];
            } else {
                path_str[pathIdx++] = parts[1][i];
            }
        }
        path_str[pathIdx] = '\0';
        query_str[queryIdx] = '\0';
        
        cJSON_SetValuestring(path, path_str);
        
        if (strlen(query_str) > 0) {
            char *pairs = strtok(query_str, "&");
            while (pairs != NULL) {
                char *eq = strchr(pairs, '=');
                if (eq) {
                    *eq = '\0';
                    cJSON_AddStringToObject(query, pairs, eq + 1);
                } else {
                    cJSON_AddStringToObject(query, pairs, "");
                }
                pairs = strtok(NULL, "&");
            }
        }
    }
    
    // Find headers
    int headerEnd = lineCount;
    for (int i = 1; i < lineCount; i++) {
        if (strlen(lines[i]) == 0) {
            headerEnd = i;
            break;
        }
    }
    
    // Parse headers character by character
    for (int i = 1; i < headerEnd; i++) {
        char *line = lines[i];
        char key[256] = "";
        char value[512] = "";
        int foundColon = 0;
        int keyIdx = 0, valueIdx = 0;
        
        for (int j = 0; j < strlen(line); j++) {
            if (line[j] == ':' && !foundColon) {
                foundColon = 1;
            } else if (foundColon) {
                value[valueIdx++] = line[j];
            } else {
                key[keyIdx++] = line[j];
            }
        }
        
        if (foundColon) {
            key[keyIdx] = '\0';
            value[valueIdx] = '\0';
            // Trim whitespace
            while (value[0] == ' ') memmove(value, value + 1, strlen(value));
            cJSON_AddStringToObject(headers, key, value);
        }
    }
    
    // Body
    if (headerEnd + 1 < lineCount) {
        char body_str[4096] = "";
        for (int i = headerEnd + 1; i < lineCount; i++) {
            if (i > headerEnd + 1) strcat(body_str, "\n");
            strcat(body_str, lines[i]);
        }
        cJSON_SetValuestring(body, body_str);
    }
    
    // Cleanup
    for (int i = 0; i < lineCount; i++) {
        free(lines[i]);
    }
    free(copy);
    
    return result;
}

int main() {
    char rawRequest[8192] = "";
    char line[1024];
    while (fgets(line, sizeof(line), stdin)) {
        strcat(rawRequest, line);
    }
    
    // Remove final newline if present
    int len = strlen(rawRequest);
    if (len > 0 && rawRequest[len-1] == '\n') {
        rawRequest[len-1] = '\0';
    }
    
    cJSON *result = solution(rawRequest);
    char *json_string = cJSON_Print(result);
    printf("%s\n", json_string);
    
    free(json_string);
    cJSON_Delete(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Multiple scans through the string for different components, plus string operations

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for parsed headers, query parameters, and result object

⚡ Linearithmic Space

76.5K Views

Medium-High Frequency

~35 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

HTTP Request Parser - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Character-by-Character Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler