url_utils.h File Reference

Utility functions for URL decoding, form parsing, MIME type lookup, and IP address extraction. More...

#include <string>
#include <unordered_map>
#include <sstream>

Include dependency graph for url_utils.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
std::string	trim (const std::string &s)
	Trim whitespace from the beginning and end of a string.
std::string	urlDecode (const std::string &src)
	Decode a URL-encoded string (e.g., "a%20b+c" -> "a b c").
std::unordered_multimap< std::string, std::string >	parseUrlEncoded (const std::string &data)
	Parse a URL-encoded key-value string into a map.
std::string	getClientIpFromSocket (int sock)
	Get the client IP address from a socket.
std::string	getMimeType (const std::string &filePath)
	Get the MIME type based on a file path's extension.

Detailed Description

These functions support core HTTP functionality including decoding URL-encoded strings, parsing application/x-www-form-urlencoded bodies, detecting client IP addresses, and determining appropriate MIME types for static file serving.

Version

0.1

Date

2025-03-31

Author

...

Copyright

MIT

Definition in file url_utils.h.

Function Documentation

getClientIpFromSocket()

std::string getClientIpFromSocket

(

int

sock

)

Uses lwIP's lwip_getpeername() to extract the IP address of the remote peer.

Parameters

sock	The socket file descriptor.

Returns

The client IP address as a string. Returns "0.0.0.0" on failure.

getMimeType()

std::string getMimeType

(

const std::string &

filePath

)

Used when serving static files to determine the appropriate Content-Type.

Parameters

filePath

The file path (e.g., "/index.html").

Returns

A MIME type string (e.g., "text/html").

Get the MIME type based on a file path's extension.

Get the MIME type based on a file path's extension.

Definition at line 105 of file url_utils.cpp.

{
    static const std::unordered_map<std::string, std::string> mimeTypes = {
        {".html", "text/html"},
        {".css", "text/css"},
        {".js", "application/javascript"},
        {".json", "application/json"},
        {".jpg", "image/jpeg"},
        {".jpeg", "image/jpeg"},
        {".png", "image/png"},
        {".gif", "image/gif"},
        {".txt", "text/plain"},
        {".xml", "application/xml"},
        {".pdf", "application/pdf"},
        {".zip", "application/zip"},
        {".mp4", "video/mp4"},
        {".mp3", "audio/mpeg"},
        {".wav", "audio/wav"},
        {".csv", "text/csv"}};
 
    size_t extPos = filePath.find_last_of(".");
    if (extPos != std::string::npos)
    {
        std::string ext = filePath.substr(extPos); // Extract extension
        auto it = mimeTypes.find(ext);
        if (it != mimeTypes.end())
        {
            return it->second; // Return corresponding MIME type
        }
    }
 
    return "application/octet-stream"; // Default MIME type
}

Referenced by FileHandler::serveFile().

Here is the caller graph for this function:

parseUrlEncoded()

std::unordered_multimap< std::string, std::string > parseUrlEncoded

(

const std::string &

data

)

Converts data in the format "key1=value1&key2=value2" into a map. Both keys and values are URL-decoded.

Parameters

data	URL-encoded form data.

Returns

A map of key-value pairs.

Parse a URL-encoded key-value string into a map.

Parse a URL-encoded key-value string into a map.

Definition at line 67 of file url_utils.cpp.

{
    std::unordered_multimap<std::string, std::string> params;
 
    std::istringstream stream(data);
    std::string pair;
    while (std::getline(stream, pair, '&'))
    {
        size_t pos = pair.find('=');
        if (pos != std::string::npos)
        {
            std::string key = pair.substr(0, pos);
            std::string value = pair.substr(pos + 1);
            // Decode both key and value
            params.emplace(urlDecode(key), urlDecode(value));
        }
    }
    return params;
}

References urlDecode().

Referenced by HttpRequest::getFormParams(), and HttpRequest::getQueryParams().

Here is the call graph for this function:

Here is the caller graph for this function:

trim()

std::string trim ( const std::string &  s )

inline

Parameters

s	The input string.

Returns

A new string with leading/trailing whitespace removed.

Definition at line 27 of file url_utils.h.

                                           {
     size_t start = s.find_first_not_of(" \t\r\n");
     size_t end = s.find_last_not_of(" \t\r\n");
     return (start == std::string::npos) ? "" : s.substr(start, end - start + 1);
 }

urlDecode()

std::string urlDecode

(

const std::string &

src

)

Converts percent-encoded characters and replaces '+' with space.

Parameters

src	The URL-encoded input string.

Returns

The decoded string.

Decode a URL-encoded string (e.g., "a%20b+c" -> "a b c").

Decode a URL-encoded string (e.g., "a%20b+c" -> "a b c").

Definition at line 28 of file url_utils.cpp.

{
    std::string ret;
    for (size_t i = 0; i < src.length(); ++i)
    {
        if (src[i] == '%')
        {
            if (i + 2 < src.length())
            {
                std::istringstream iss(src.substr(i + 1, 2));
                int hexVal;
                if (iss >> std::hex >> hexVal)
                {
                    ret += static_cast<char>(hexVal);
                    i += 2;
                }
                else
                {
                    ret += '%';
                }
            }
            else
            {
                ret += '%';
            }
        }
        else if (src[i] == '+')
        {
            ret += ' ';
        }
        else
        {
            ret += src[i];
        }
    }
    return ret;
}

Referenced by HttpFileserver::handle_static_request(), Router::handleRequest(), and parseUrlEncoded().

Here is the caller graph for this function: