http2_plugin.c

#include "http2_plugin.h"
#include "logging.h"
#include "utils.h"
#include "plugin_manager.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/socket.h>
#include <errno.h>

// Variables globales para el plugin de HTTP/2
static int g_http2_initialized = 0;
static server_interface_t* g_server_iface = NULL;

// Estados de stream HTTP/2
typedef enum {
    HTTP2_STREAM_IDLE = 0,
    HTTP2_STREAM_RESERVED_LOCAL,
    HTTP2_STREAM_RESERVED_REMOTE,
    HTTP2_STREAM_OPEN,
    HTTP2_STREAM_HALF_CLOSED_LOCAL,
    HTTP2_STREAM_HALF_CLOSED_REMOTE,
    HTTP2_STREAM_CLOSED
} http2_stream_state_t;

// Parsear un frame HTTP/2
int http2_parse_frame(const char* data, size_t len, http2_frame_header_t* header) {
    if (!data || !header || len < 9) {
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Datos insuficientes para parsear frame");
        }
        return -1;
    }
    
    // El frame de HTTP/2 tiene formato: 3 bytes length, 1 byte type, 1 byte flags, 4 bytes stream id
    const unsigned char* bytes = (const unsigned char*)data;
    
    header->length = (bytes[0] << 16) | (bytes[1] << 8) | bytes[2];
    header->type = bytes[3];
    header->flags = bytes[4];
    header->stream_id = ((bytes[5] & 0x7F) << 24) | (bytes[6] << 16) | (bytes[7] << 8) | bytes[8];
    
    // Validar que el stream_id no sea 0 para frames que no deben usarlo
    if (header->type != HTTP2_FRAME_SETTINGS && header->type != HTTP2_FRAME_PING && header->stream_id == 0) {
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Frame inválido con stream_id 0");
        }
        return -1;
    }
    
    return 0;
}

// Parsear frame SETTINGS
int http2_parse_settings_frame(const unsigned char* payload, size_t len, http2_settings_frame_t* settings) {
    if (!payload || !settings) return -1;
    
    if (len % 6 != 0) {
        // Los SETTINGS tienen entradas de 6 bytes cada una (2 de id + 4 de valor)
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Frame SETTINGS inválido");
        }
        return -1;
    }
    
    settings->settings_params_count = len / 6;
    if (settings->settings_params_count == 0) {
        settings->settings_params = NULL;
        return 0;
    }
    
    settings->settings_params = g_server_iface->allocate_memory(
        settings->settings_params_count * sizeof(http2_settings_param_t));
    if (!settings->settings_params) {
        return -1;
    }
    
    for (size_t i = 0; i < settings->settings_params_count; i++) {
        size_t offset = i * 6;
        settings->settings_params[i].identifier = 
            (payload[offset] << 8) | payload[offset + 1];
        settings->settings_params[i].value = 
            (payload[offset + 2] << 24) | (payload[offset + 3] << 16) | 
            (payload[offset + 4] << 8) | payload[offset + 5];
    }
    
    return 0;
}

// Parsear frame HEADERS
int http2_parse_headers_frame(const unsigned char* payload, size_t len, 
                              const http2_frame_header_t* header, http2_headers_frame_t* hframe) {
    if (!payload || !header || !hframe) return -1;
    
    size_t offset = 0;
    
    // Verificar si tiene padding
    if (header->flags & HTTP2_FLAG_PADDED) {
        if (offset >= len) return -1;
        hframe->pad_length = payload[offset];
        offset++;
    } else {
        hframe->pad_length = 0;
    }
    
    // Verificar si tiene prioridad
    if (header->flags & HTTP2_FLAG_PRIORITY) {
        if (offset + 5 > len) return -1;
        hframe->stream_dependency = (payload[offset] << 24) | (payload[offset + 1] << 16) | 
                                   (payload[offset + 2] << 8) | payload[offset + 3];
        hframe->exclusive = (hframe->stream_dependency >> 31) & 0x1;
        hframe->stream_dependency &= 0x7FFFFFFF; // Limpiar bit exclusivo
        hframe->weight = payload[offset + 4];
        offset += 5;
    } else {
        hframe->stream_dependency = 0;
        hframe->exclusive = 0;
        hframe->weight = 0;
    }
    
    // El resto es el fragmento de bloque de headers
    hframe->header_block_fragment_len = len - offset - hframe->pad_length;
    if (hframe->header_block_fragment_len > 0) {
        hframe->header_block_fragment = g_server_iface->allocate_memory(hframe->header_block_fragment_len);
        if (!hframe->header_block_fragment) {
            return -1;
        }
        memcpy(hframe->header_block_fragment, payload + offset, hframe->header_block_fragment_len);
    } else {
        hframe->header_block_fragment = NULL;
    }
    
    return 0;
}

// Parsear frame DATA
int http2_parse_data_frame(const unsigned char* payload, size_t len, 
                           const http2_frame_header_t* header, http2_data_frame_t* dframe) {
    if (!payload || !header || !dframe) return -1;
    
    size_t offset = 0;
    
    // Verificar si tiene padding
    if (header->flags & HTTP2_FLAG_PADDED) {
        if (offset >= len) return -1;
        dframe->pad_length = payload[offset];
        offset++;
    } else {
        dframe->pad_length = 0;
    }
    
    // El resto es el cuerpo de datos
    dframe->data_len = len - offset - dframe->pad_length;
    if (dframe->data_len > 0) {
        dframe->data = g_server_iface->allocate_memory(dframe->data_len);
        if (!dframe->data) {
            return -1;
        }
        memcpy(dframe->data, payload + offset, dframe->data_len);
    } else {
        dframe->data = NULL;
    }
    
    return 0;
}

// Inicializar conexión HTTP/2
int http2_initialize_connection(int socket_fd, http2_connection_t** conn) {
    if (!conn) return -1;
    
    *conn = g_server_iface->allocate_memory(sizeof(http2_connection_t));
    if (!*conn) {
        return -1;
    }
    
    // Inicializar la conexión con valores por defecto
    (*conn)->socket_fd = socket_fd;
    (*conn)->last_stream_id = 0;
    (*conn)->max_concurrent_streams = 100;  // Valor por defecto
    (*conn)->initial_window_size = 65535;   // Valor por defecto
    (*conn)->max_frame_size = 16384;        // Valor por defecto
    (*conn)->streams = NULL;
    (*conn)->stream_count = 0;
    (*conn)->stream_capacity = 0;
    
    // Enviar SETTINGS iniciales
    send_http2_settings_frame(socket_fd);
    
    if (g_server_iface && g_server_iface->log_message) {
        g_server_iface->log_message(1, "HTTP/2: Conexión inicializada en socket %d", socket_fd);
    }
    
    return 0;
}

// Limpiar conexión HTTP/2
int http2_cleanup_connection(http2_connection_t* conn) {
    if (!conn) return 0;
    
    if (conn->streams) {
        for (size_t i = 0; i < conn->stream_count; i++) {
            if (conn->streams[i].request_data) {
                g_server_iface->free_memory(conn->streams[i].request_data);
            }
        }
        g_server_iface->free_memory(conn->streams);
    }
    
    g_server_iface->free_memory(conn);
    
    if (g_server_iface && g_server_iface->log_message) {
        g_server_iface->log_message(1, "HTTP/2: Conexión limpiada");
    }
    
    return 0;
}

// Enviar frame HTTP/2 genérico
int http2_send_frame(int socket_fd, http2_frame_type_t type, 
                     unsigned char flags, unsigned int stream_id, 
                     const unsigned char* payload, size_t payload_len) {
    if (payload_len > 0xFFFFFF) {  // Límite de 24 bits para el tamaño
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Frame demasiado largo");
        }
        return -1;
    }
    
    // El frame tiene 9 bytes de cabecera + payload
    size_t frame_size = 9 + payload_len;
    unsigned char* frame = g_server_iface->allocate_memory(frame_size);
    if (!frame) {
        return -1;
    }
    
    // Escribir cabecera: 3 bytes length, 1 byte type, 1 byte flags, 4 bytes stream_id
    frame[0] = (payload_len >> 16) & 0xFF;
    frame[1] = (payload_len >> 8) & 0xFF;
    frame[2] = payload_len & 0xFF;
    frame[3] = (unsigned char)type;
    frame[4] = flags;
    frame[5] = (stream_id >> 24) & 0x7F;  // Bit MSB debe ser 0
    frame[6] = (stream_id >> 16) & 0xFF;
    frame[7] = (stream_id >> 8) & 0xFF;
    frame[8] = stream_id & 0xFF;
    
    // Copiar payload si existe
    if (payload && payload_len > 0) {
        memcpy(frame + 9, payload, payload_len);
    }
    
    // Enviar frame completo
    ssize_t sent = send(socket_fd, frame, frame_size, 0);
    g_server_iface->free_memory(frame);
    
    if (sent != (ssize_t)frame_size) {
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Error al enviar frame");
        }
        return -1;
    }
    
    return 0;
}

// Enviar SETTINGS frame
int send_http2_settings_frame(int socket_fd) {
    // Enviar settings: ENABLE_PUSH (0) = 0
    unsigned char settings_payload[6];
    settings_payload[0] = 0x00;  // SETTINGS_ENABLE_PUSH
    settings_payload[1] = 0x02;  // (0x02)
    settings_payload[2] = 0x00;  // Valor: 0 (deshabilitar server push)
    settings_payload[3] = 0x00;
    settings_payload[4] = 0x00;
    settings_payload[5] = 0x00;
    
    int result = http2_send_frame(socket_fd, HTTP2_FRAME_SETTINGS, 0, 0, settings_payload, 6);
    
    if (g_server_iface && g_server_iface->log_message) {
        if (result == 0) {
            g_server_iface->log_message(1, "HTTP/2: SETTINGS frame enviado");
        } else {
            g_server_iface->log_message(3, "HTTP/2: Error al enviar SETTINGS frame");
        }
    }
    
    return result;
}

// Enviar SETTINGS ACK frame
int send_http2_settings_ack_frame(int socket_fd) {
    int result = http2_send_frame(socket_fd, HTTP2_FRAME_SETTINGS, HTTP2_FLAG_ACK, 0, NULL, 0);
    
    if (g_server_iface && g_server_iface->log_message) {
        if (result == 0) {
            g_server_iface->log_message(1, "HTTP/2: SETTINGS ACK frame enviado");
        } else {
            g_server_iface->log_message(3, "HTTP/2: Error al enviar SETTINGS ACK frame");
        }
    }
    
    return result;
}

// Enviar HEADERS frame
int send_http2_headers_frame(int socket_fd, unsigned int stream_id, 
                             const unsigned char* header_block, size_t header_len) {
    // Esto es una simplificación - en la práctica, los headers deben estar comprimidos con HPACK
    int result = http2_send_frame(socket_fd, HTTP2_FRAME_HEADERS, HTTP2_FLAG_END_HEADERS, stream_id, 
                                  header_block, header_len);
    
    if (g_server_iface && g_server_iface->log_message) {
        if (result == 0) {
            g_server_iface->log_message(1, "HTTP/2: HEADERS frame enviado para stream %d", stream_id);
        } else {
            g_server_iface->log_message(3, "HTTP/2: Error al enviar HEADERS frame para stream %d", stream_id);
        }
    }
    
    return result;
}

// Enviar DATA frame
int send_http2_data_frame(int socket_fd, unsigned int stream_id, 
                          const unsigned char* data, size_t data_len) {
    unsigned char flags = HTTP2_FLAG_END_STREAM;  // Suponemos que termina el stream
    
    int result = http2_send_frame(socket_fd, HTTP2_FRAME_DATA, flags, stream_id, data, data_len);
    
    if (g_server_iface && g_server_iface->log_message) {
        if (result == 0) {
            g_server_iface->log_message(1, "HTTP/2: DATA frame enviado para stream %d", stream_id);
        } else {
            g_server_iface->log_message(3, "HTTP/2: Error al enviar DATA frame para stream %d", stream_id);
        }
    }
    
    return result;
}

// Manejar frame SETTINGS
int http2_handle_settings_frame(http2_connection_t* conn, const http2_frame_header_t* header, http2_settings_frame_t* settings) {
    (void)conn;  // Evitar warning si no se usa
    
    if (header->flags & HTTP2_FLAG_ACK) {
        // Este es un ACK, no hay payload
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(1, "HTTP/2: Recibido SETTINGS ACK");
        }
        return 0;
    }
    
    // Procesar los parámetros de SETTINGS
    for (size_t i = 0; i < settings->settings_params_count; i++) {
        unsigned short id = settings->settings_params[i].identifier;
        unsigned int value = settings->settings_params[i].value;
        
        switch (id) {
            case 1:  // SETTINGS_HEADER_TABLE_SIZE
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: SETTINGS_HEADER_TABLE_SIZE = %u", value);
                }
                break;
            case 2:  // SETTINGS_ENABLE_PUSH
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: SETTINGS_ENABLE_PUSH = %u", value);
                }
                break;
            case 3:  // SETTINGS_MAX_CONCURRENT_STREAMS
                conn->max_concurrent_streams = value;
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: SETTINGS_MAX_CONCURRENT_STREAMS = %u", value);
                }
                break;
            case 4:  // SETTINGS_INITIAL_WINDOW_SIZE
                conn->initial_window_size = value;
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: SETTINGS_INITIAL_WINDOW_SIZE = %u", value);
                }
                break;
            case 5:  // SETTINGS_MAX_FRAME_SIZE
                conn->max_frame_size = value;
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: SETTINGS_MAX_FRAME_SIZE = %u", value);
                }
                break;
            case 6:  // SETTINGS_MAX_HEADER_LIST_SIZE
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: SETTINGS_MAX_HEADER_LIST_SIZE = %u", value);
                }
                break;
            default:
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(2, "HTTP/2: Parámetro desconocido en SETTINGS: %u", id);
                }
                break;
        }
    }
    
    // Enviar ACK de SETTINGS
    send_http2_settings_ack_frame(conn->socket_fd);
    
    return 0;
}

// Manejar frame HEADERS
int http2_handle_headers_frame(http2_connection_t* conn, const http2_frame_header_t* header, http2_headers_frame_t* hframe) {
    (void)hframe;  // Evitar warning si no se usa
    
    if (g_server_iface && g_server_iface->log_message) {
        g_server_iface->log_message(1, "HTTP/2: Recibido HEADERS frame para stream %u", header->stream_id);
    }
    
    // Actualizar el ID del último stream si es más alto
    if (header->stream_id > conn->last_stream_id) {
        conn->last_stream_id = header->stream_id;
    }
    
    // Aquí iría la lógica para descomprimir y procesar los headers HPACK
    // y crear una solicitud HTTP a partir de ellos
    
    // Si el frame tiene END_HEADERS, procesamos la solicitud completa
    if (header->flags & HTTP2_FLAG_END_HEADERS) {
        // Aquí se procesaría la solicitud HTTP basada en los headers
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(1, "HTTP/2: Procesando solicitud completa para stream %u", header->stream_id);
        }
    }
    
    return 0;
}

// Manejar frame DATA
int http2_handle_data_frame(http2_connection_t* conn, const http2_frame_header_t* header, http2_data_frame_t* dframe) {
    (void)conn;   // Evitar warning si no se usa
    (void)dframe; // Evitar warning si no se usa

    if (g_server_iface && g_server_iface->log_message) {
        g_server_iface->log_message(1, "HTTP/2: Recibido DATA frame para stream %u, tamaño: %u",
                                   header->stream_id, header->length);
    }

    // Aquí iría la lógica para procesar los datos del frame
    // y combinarlos con los headers previamente recibidos

    return 0;
}

// Manejar frame PING
int http2_handle_ping_frame(http2_connection_t* conn, const http2_frame_header_t* header) {
    // El payload de PING debe tener 8 bytes
    if (header->length != 8) {
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Frame PING inválido");
        }
        return -1;
    }

    // Leer el payload del PING actual para eco
    unsigned char ping_payload[8];
    // En un entorno real, el payload vendría en el frame recibido
    // Aquí lo inicializamos con ceros como ejemplo
    memset(ping_payload, 0, 8);

    int result = http2_send_frame(conn->socket_fd, HTTP2_FRAME_PING, HTTP2_FLAG_ACK, 0,
                                  ping_payload, 8);

    if (g_server_iface && g_server_iface->log_message) {
        if (result == 0) {
            g_server_iface->log_message(1, "HTTP/2: PING respondido");
        } else {
            g_server_iface->log_message(3, "HTTP/2: Error al responder PING");
        }
    }

    return result;
}

// Manejar conexión HTTP/2
int http2_handle_connection(int socket_fd) {
    if (g_server_iface && g_server_iface->log_message) {
        g_server_iface->log_message(1, "HTTP/2: Manejando nueva conexión en socket %d", socket_fd);
    }
    
    // Inicializar la conexión
    http2_connection_t* conn;
    if (http2_initialize_connection(socket_fd, &conn) != 0) {
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(3, "HTTP/2: Error al inicializar conexión");
        }
        return -1;
    }
    
    // Recibir y procesar frames
    unsigned char buffer[16384];  // Tamaño máximo de frame
    ssize_t bytes_read;
    
    // Recibir preámbulo HTTP/2 si es necesario
    unsigned char preface[24];
    bytes_read = recv(socket_fd, preface, 24, MSG_PEEK);  // Verificar sin consumir
    if (bytes_read >= 24 && memcmp(preface, HTTP2_CONNECTION_PREFACE, 24) == 0) {
        // Consumir el preámbulo
        recv(socket_fd, preface, 24, 0);
        if (g_server_iface && g_server_iface->log_message) {
            g_server_iface->log_message(1, "HTTP/2: Preámbulo válido recibido");
        }
    }
    
    // Bucle principal de procesamiento de frames
    while (g_running) {
        bytes_read = recv(conn->socket_fd, buffer, sizeof(buffer), 0);
        if (bytes_read <= 0) {
            if (bytes_read == 0) {
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(1, "HTTP/2: Cliente desconectado");
                }
            } else {
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(3, "HTTP/2: Error al recibir datos: %s", strerror(errno));
                }
            }
            break;
        }
        
        size_t processed = 0;
        while (processed < (size_t)bytes_read) {
            if ((size_t)bytes_read - processed < 9) {
                // No hay suficientes bytes para un frame header
                break;
            }
            
            http2_frame_header_t frame_header;
            if (http2_parse_frame((const char*)(buffer + processed), 
                                 bytes_read - processed, &frame_header) != 0) {
                if (g_server_iface && g_server_iface->log_message) {
                    g_server_iface->log_message(3, "HTTP/2: Error al parsear frame");
                }
                break;
            }
            
            // Asegurarse de tener todos los bytes para este frame
            size_t frame_size = 9 + frame_header.length;
            if (processed + frame_size > (size_t)bytes_read) {
                // No tenemos todos los bytes de este frame, esperar más
                break;
            }
            
            // Procesar el frame según su tipo
            switch (frame_header.type) {
                case HTTP2_FRAME_DATA: {
                    http2_data_frame_t dframe;
                    if (http2_parse_data_frame(buffer + processed + 9, frame_header.length, 
                                               &frame_header, &dframe) == 0) {
                        http2_handle_data_frame(conn, &frame_header, &dframe);
                        if (dframe.data) {
                            g_server_iface->free_memory(dframe.data);
                        }
                    }
                    break;
                }
                case HTTP2_FRAME_HEADERS: {
                    http2_headers_frame_t hframe;
                    if (http2_parse_headers_frame(buffer + processed + 9, frame_header.length, 
                                                  &frame_header, &hframe) == 0) {
                        http2_handle_headers_frame(conn, &frame_header, &hframe);
                        if (hframe.header_block_fragment) {
                            g_server_iface->free_memory(hframe.header_block_fragment);
                        }
                    }
                    break;
                }
                case HTTP2_FRAME_SETTINGS: {
                    http2_settings_frame_t sframe;
                    if (http2_parse_settings_frame(buffer + processed + 9, frame_header.length, 
                                                   &sframe) == 0) {
                        http2_handle_settings_frame(conn, &frame_header, &sframe);
                        if (sframe.settings_params) {
                            g_server_iface->free_memory(sframe.settings_params);
                        }
                    }
                    break;
                }
                case HTTP2_FRAME_PING: {
                    http2_handle_ping_frame(conn, &frame_header);
                    break;
                }
                default:
                    if (g_server_iface && g_server_iface->log_message) {
                        g_server_iface->log_message(2, "HTTP/2: Frame no implementado: %u", frame_header.type);
                    }
                    break;
            }
            
            processed += frame_size;
        }
        
        // Si no se procesó ningún frame en este buffer, puede haber un error
        if (processed == 0) {
            break;
        }
    }
    
    // Limpiar la conexión
    http2_cleanup_connection(conn);
    
    return 0;
}

int http2_process_request(const void* request, void** response) {
    (void)request;  // Evitar warning de parámetro no utilizado
    (void)response; // Evitar warning de parámetro no utilizado
    
    // Simulación de procesamiento de request HTTP/2
    // En una implementación real, aquí se procesaría el frame HTTP/2
    if (g_server_iface && g_server_iface->log_message) {
        g_server_iface->log_message(1, "HTTP/2: Procesando request");
    }
    return 0;
}

// Implementación de las funciones del plugin
int http2_plugin_init(void* config) {
    (void)config;   // Evitar warning de parámetro no utilizado
    
    if (g_logging_enabled) {
        write_log(1, "HTTP/2: Inicializando plugin HTTP/2");
    }
    
    g_http2_initialized = 1;
    
    // Aquí iría la lógica para inicializar el protocolo HTTP/2
    // como configurar los SETTINGS iniciales, etc.
    
    if (g_logging_enabled) {
        write_log(1, "HTTP/2: Plugin HTTP/2 inicializado correctamente");
    }
    
    return 0;
}

int http2_plugin_process_request(void* request_data, void** response_data) {
    (void)request_data;   // Evitar warning de parámetro no utilizado
    (void)response_data;  // Evitar warning de parámetro no utilizado
    
    if (!g_http2_initialized) {
        if (g_logging_enabled) {
            write_log(3, "HTTP/2: Plugin HTTP/2 no está inicializado");
        }
        return -1;
    }
    
    // Aquí iría la lógica para procesar una solicitud HTTP/2
    // Para esta implementación, solo registramos la operación
    if (g_logging_enabled) {
        write_log(1, "HTTP/2: Procesando solicitud HTTP/2 a través del plugin");
    }
    
    // En una implementación completa, aquí parsearíamos los frames HTTP/2,
    // manejaríamos los streams, etc.
    
    // Simular éxito
    return 0;
}

int http2_plugin_cleanup(void) {
    if (g_logging_enabled) {
        write_log(1, "HTTP/2: Limpiando plugin HTTP/2");
    }
    
    g_http2_initialized = 0;
    return 0;
}

void* http2_plugin_get_interface(const char* interface_name) {
    if (!interface_name) return NULL;
    
    // Devolver interfaces específicas según el nombre solicitado
    if (strcmp(interface_name, "http2_frame_parser") == 0) {
        // Devolver una estructura con las funciones para parsear frames
        static http2_plugin_interface_t frame_iface = {
            .parse_frame = http2_parse_frame,
            .parse_settings_frame = http2_parse_settings_frame,
            .parse_headers_frame = http2_parse_headers_frame,
            .parse_data_frame = http2_parse_data_frame,
            .handle_connection = http2_handle_connection,
            .initialize_connection = http2_initialize_connection,
            .cleanup_connection = http2_cleanup_connection,
            .handle_settings_frame = http2_handle_settings_frame,
            .handle_headers_frame = http2_handle_headers_frame,
            .handle_data_frame = http2_handle_data_frame,
            .handle_ping_frame = http2_handle_ping_frame,
            .send_frame = http2_send_frame,
            .process_request = http2_process_request
        };
        return &frame_iface;
    }
    
    return NULL;
}

// Definición de la interfaz del plugin
plugin_interface_t http2_plugin = {
    .name = "HTTP/2 Protocol Handler",
    .version = "1.0.0",
    .api_version = PLUGIN_API_VERSION,
    .type = PLUGIN_HTTP_PROTOCOL,
    .init = http2_plugin_init,
    .process_request = http2_plugin_process_request,
    .cleanup = http2_plugin_cleanup,
    .get_interface = http2_plugin_get_interface
};

// Función para registrar el plugin con el sistema principal
int register_http2_plugin(server_interface_t* server_iface) {
    g_server_iface = server_iface;
    
    // Registrar el plugin con el sistema de plugins
    if (register_plugin_interface(&http2_plugin) != 0) {
        if (g_logging_enabled) {
            write_log(3, "HTTP/2: Error al registrar el plugin HTTP/2");
        }
        return -1;
    }
    
    if (g_logging_enabled) {
        write_log(1, "HTTP/2: Plugin HTTP/2 registrado en el sistema");
    }
    
    return 0;
}