astralis/vapi/libmicrohttpd.vapi

[CCode (cheader_filename = "microhttpd.h")]
namespace MHD {
    [CCode (cname = "enum MHD_ValueKind", cprefix = "MHD_")]
    public enum ValueKind {
        RESPONSE_HEADER_KIND,
        HEADER_KIND,
        COOKIE_KIND,
        POSTDATA_KIND,
        GET_ARGUMENT_KIND,
        FOOTER_KIND
    }

    [CCode (cname = "enum MHD_RequestTerminationCode", cprefix = "MHD_REQUEST_TERMINATED_")]
    public enum RequestTerminationCode {
        COMPLETED_OK,
        WITH_ERROR,
        TIMEOUT_REACHED,
        DAEMON_SHUTDOWN,
        READ_ERROR,
        CLIENT_ABORT
    }

    [CCode (cname = "enum MHD_ResponseMemoryMode", cprefix = "MHD_")]
    public enum ResponseMemoryMode {
        RESPMEM_PERSISTENT,
        RESPMEM_MUST_FREE,
        RESPMEM_MUST_COPY
    }

    [CCode (cname = "MHD_CONTENT_READER_END_OF_STREAM")]
    public const ssize_t CONTENT_READER_END_OF_STREAM;
    [CCode (cname = "MHD_CONTENT_READER_END_WITH_ERROR")]
    public const ssize_t CONTENT_READER_END_WITH_ERROR;

    [CCode (cname = "MHD_USE_SELECT_INTERNALLY")]
    public const uint USE_SELECT_INTERNALLY;
    [CCode (cname = "MHD_USE_THREAD_PER_CONNECTION")]
    public const uint USE_THREAD_PER_CONNECTION;
    [CCode (cname = "MHD_USE_DEBUG")]
    public const uint USE_DEBUG;
    [CCode (cname = "MHD_ALLOW_SUSPEND_RESUME")]
    public const uint ALLOW_SUSPEND_RESUME;
    [CCode (cname = "MHD_USE_TURBO")]
    public const uint USE_TURBO;
    [CCode (cname = "MHD_USE_EPOLL")]
    public const uint USE_EPOLL;
    [CCode (cname = "MHD_USE_POLL")]
    public const uint USE_POLL;
    [CCode (cname = "MHD_USE_AUTO")]
    public const uint USE_AUTO;

    [CCode (cname = "MHD_OPTION_END")]
    public const int OPTION_END;
    [CCode (cname = "MHD_OPTION_NOTIFY_COMPLETED")]
    public const int OPTION_NOTIFY_COMPLETED;
    [CCode (cname = "MHD_OPTION_CONNECTION_MEMORY_LIMIT")]
    public const int OPTION_CONNECTION_MEMORY_LIMIT;
    [CCode (cname = "MHD_OPTION_CONNECTION_LIMIT")]
    public const int OPTION_CONNECTION_LIMIT;
    [CCode (cname = "MHD_OPTION_CONNECTION_TIMEOUT")]
    public const int OPTION_CONNECTION_TIMEOUT;
    [CCode (cname = "MHD_OPTION_PER_IP_CONNECTION_LIMIT")]
    public const int OPTION_PER_IP_CONNECTION_LIMIT;

    [SimpleType]
    [CCode (cname = "struct MHD_Connection*")]
    public struct Connection {}

    [CCode (cname = "int", cprefix = "MHD_")]
    public enum Result {
        YES = 1,
        NO = 0
    }

    [Compact]
    [CCode (cname = "struct MHD_Response", free_function = "MHD_destroy_response")]
    public class Response {
        [CCode (cname = "MHD_create_response_from_buffer")]
        public Response.from_buffer (size_t size, [CCode(array_length=false)] uint8[] buffer, ResponseMemoryMode mode);

        [CCode (cname = "MHD_create_response_from_callback")]
        public Response.from_callback (uint64 size, size_t block_size, ContentReaderCallback crc, void* crc_cls, ContentReaderFreeCallback? crfc);

        [CCode (cname = "MHD_add_response_header")]
        public int add_header (string header, string content);
    }

    [Compact]
    [CCode (cname = "struct MHD_Daemon", free_function = "MHD_stop_daemon")]
    public class Daemon {
        [CCode (cname = "MHD_start_daemon")]
        public static Daemon start (uint flags, uint16 port, 
            AcceptPolicyCallback? apc, 
            AccessHandlerCallback dh, 
            ...);
    }

    [CCode (instance_pos = 0)]
    public delegate int AcceptPolicyCallback (void* cls, void* addr, uint addrlen);

    [CCode (instance_pos = 0)]
    public delegate int AccessHandlerCallback (Connection connection, 
        string? url, string? method, string? version, 
        string? upload_data, [CCode(array_length=false)] size_t* upload_data_size, 
        void** con_cls);

    [CCode (has_target = false)]
    public delegate ssize_t ContentReaderCallback (void* cls, uint64 pos, char* buf, size_t max);

    [CCode (has_target = false, cname = "MHD_ContentReaderFreeCallback")]
    public delegate void ContentReaderFreeCallback (void* cls);
    
    [CCode (cname = "MHD_queue_response")]
    public int queue_response (Connection connection, uint status_code, Response response);

    [CCode (cname = "MHD_suspend_connection")]
    public int suspend_connection (Connection connection);

    [CCode (cname = "MHD_resume_connection")]
    public int resume_connection (Connection connection);

    [CCode (cname = "MHD_lookup_connection_value")]
    public unowned string? lookup_connection_value (Connection connection, ValueKind kind, string key);

    [CCode (has_target = false)]
    public delegate Result KeyValueIterator (void* cls, ValueKind kind, string key, string? value);

    [CCode (has_target = false, cname = "MHD_RequestCompletedCallback")]
    public delegate void RequestCompletedCallback (void* cls, Connection connection, void** con_cls, RequestTerminationCode toe);

    [CCode (cname = "MHD_get_connection_values")]
    public int get_connection_values (Connection connection, ValueKind kind, KeyValueIterator? iterator, void* iterator_cls = null);

    [CCode (cname = "enum MHD_ConnectionInfoType", cprefix = "MHD_CONNECTION_INFO_")]
    public enum ConnectionInfoType {
        CIPHER_ALGO,
        PROTOCOL,
        CLIENT_ADDRESS,
        GNUTLS_SESSION,
        GNUTLS_CLIENT_CERT,
        DAEMON,
        CONNECTION_FD,
        SOCKET_CONTEXT,
        CONNECTION_SUSPENDED,
        CONNECTION_TIMEOUT,
        REQUEST_HEADER_SIZE,
        HTTP_STATUS
    }

    [CCode (cname = "union MHD_ConnectionInfo", has_type_id = false)]
    public struct ConnectionInfo {
        [CCode (cname = "cipher_algorithm")]
        public int cipher_algorithm;
        [CCode (cname = "protocol")]
        public int protocol;
        [CCode (cname = "client_cert")]
        public void* client_cert;
        [CCode (cname = "tls_session")]
        public void* tls_session;
        [CCode (cname = "daemon")]
        public Daemon* daemon;
        [CCode (cname = "connect_fd")]
        public int connect_fd;
        [CCode (cname = "socket_context")]
        public void* socket_context;
        [CCode (cname = "suspended")]
        public int suspended;
        [CCode (cname = "connection_timeout")]
        public uint connection_timeout;
        [CCode (cname = "client_addr")]
        public void* client_addr;
        [CCode (cname = "header_size")]
        public size_t header_size;
        [CCode (cname = "http_status")]
        public uint http_status;
    }

    [CCode (cname = "MHD_get_connection_info")]
    public unowned ConnectionInfo? get_connection_info (Connection connection, ConnectionInfoType info_type);

    // FDSet structure for external select mode
    // Note: fd_set is a struct containing an array of long integers
    // The actual size varies by platform but FD_SETSIZE is typically 1024
    [CCode (cname = "fd_set", has_type_id = false, destroy_function = "")]
    public struct FDSet {
        // Internal storage - size for FD_SETSIZE=1024 on Linux (16 * 8 bytes = 128 bytes = 1024 bits)
        [CCode (cname = "__fds_bits", array_length = false)]
        private ulong fds_bits[16];
        
        [CCode (cname = "FD_ZERO")]
        public static void zero(ref FDSet set);
        
        [CCode (cname = "FD_SET")]
        public static void set(int fd, ref FDSet set);
        
        [CCode (cname = "FD_CLR")]
        public static void clr(int fd, ref FDSet set);
        
        [CCode (cname = "FD_ISSET")]
        public static bool is_set(int fd, ref FDSet set);
    }

    // External select mode functions
    [CCode (cname = "MHD_run")]
    public Result run(Daemon daemon);

    [CCode (cname = "MHD_get_fdset")]
    public Result get_fdset(Daemon daemon, ref FDSet read_fds, ref FDSet write_fds, ref FDSet error_fds, int* max_fd);

    [CCode (cname = "MHD_get_timeout")]
    public Result get_timeout(Daemon daemon, uint64* timeout);

    [CCode (cname = "enum MHD_DaemonInfoType", cprefix = "MHD_DAEMON_INFO_")]
    public enum DaemonInfoType {
        KEY_SIZE,
        MAC_KEY_SIZE,
        LISTEN_FD,
        EPOLL_FD,
        CURRENT_CONNECTIONS,
        FLAGS,
        BIND_PORT
    }

    [CCode (cname = "union MHD_DaemonInfo", has_type_id = false)]
    public struct DaemonInfo {
        public size_t key_size;
        public size_t mac_key_size;
        public int listen_fd;
        public uint16 port;
        public int epoll_fd;
        public uint num_connections;
    }

    [CCode (cname = "MHD_get_daemon_info")]
    public unowned DaemonInfo? get_daemon_info(Daemon daemon, DaemonInfoType info_type, ...);
}