url_utils.cpp File Reference

Implementation of URL utility functions for decoding, parsing, and MIME type detection. More...

#include "http/url_utils.h"
#include <sstream>
#include <lwip/sockets.h>
#include <lwip/ip_addr.h>
#include <lwip/memp.h>
#include <string>
#include <algorithm>
#include <cctype>
#include "network/Tcp.h"

Include dependency graph for url_utils.cpp:

Go to the source code of this file.

Functions
std::string	urlDecode (const std::string &src)
std::unordered_multimap< std::string, std::string >	parseUrlEncoded (const std::string &data)
std::string	getClientIpFromTcp (Tcp *tcp)
	Get the client IP address from a socket.
std::string	getMimeType (const std::string &filePath)

Detailed Description

Author

Ian Archbell

Part of the PicoFramework HTTP server. This module provides functions for URL decoding, parsing URL-encoded form data, extracting client IP addresses from sockets, and determining MIME types based on file extensions.

Version

0.1

Date

2025-03-31

License:\n MIT License

Copyright

Copyright (c) 2025, Ian Archbell

Definition in file url_utils.cpp.

Function Documentation

getClientIpFromTcp()

std::string getClientIpFromTcp

(

Tcp *

tcp

)

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.

Definition at line 88 of file url_utils.cpp.

{
    sockaddr_in addr;
    socklen_t len = sizeof(addr);
 
    int sock = tcp->getSocketFd(); // Add this method if needed
    if (lwip_getpeername(sock, (sockaddr *)&addr, &len) == 0)
    {
        ip_addr_t ip;
        ip.addr = addr.sin_addr.s_addr;
        return std::string(ipaddr_ntoa(&ip));
    }
    return "0.0.0.0";
}

References Tcp::getSocketFd().

Here is the call graph for this function:

getMimeType()

std::string getMimeType

(

const std::string &

filePath

)

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

)

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:

urlDecode()

std::string urlDecode

(

const std::string &

src

)

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: