dany/antd-fcgi-plugin
1
0
Fork 0
mirror of https://github.com/lxsang/antd-fcgi-plugin.git synced 2024-12-26 05:08:22 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: update code to support antd 2.0.0 new plugin interface
Some checks failed
gitea-sync/antd-fcgi-plugin/pipeline/head There was a failure building this commit
Details

Browse Source
This commit is contained in:
DanyLE 2024-03-13 18:12:16 +01:00
parent bfa6020ce2
commit 6a82a98aa5
4 changed files with 132 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure.ac
View File

@ -1,5 +1,5 @@
# initialise autoconf and set up some basic information about the program we’re packaging # initialise autoconf and set up some basic information about the program we’re packaging
AC_INIT([fcgi], [0.1.0a], [xsang.le@gmail.com]) AC_INIT([fcgi], [0.2.0], [xsang.le@gmail.com])
# We’re going to use automake for this project # We’re going to use automake for this project
# [subdir-objects] if needed # [subdir-objects] if needed

218
fcgi.c
View File

@ -1,4 +1,3 @@
#define PLUGIN_IMPLEMENT 1
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <unistd.h> #include <unistd.h>
@ -19,7 +18,7 @@
#include <sys/time.h> #include <sys/time.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <antd/plugin.h>
//#include <libgen.h> //#include <libgen.h>
#include "proto.h" #include "proto.h"
@ -47,106 +46,105 @@ typedef struct {
pid_t pid; pid_t pid;
} fcgi_config_t; } fcgi_config_t;
static fcgi_config_t g_config; static int mk_socket(fcgi_config_t* config);
static int read_config(fcgi_config_t* config,antd_plugin_ctx_t* p_config);
static int mk_socket(); static int open_un_socket(fcgi_config_t* config);
static int read_config(); static int open_tcp_socket(fcgi_config_t* config);
static int open_un_socket(); static int open_socket(fcgi_config_t* config);
static int open_tcp_socket();
static int open_socket();
static char* read_line(char** buff, int* size); static char* read_line(char** buff, int* size);
static int read_header(antd_client_t* cl, antd_request_t* rq); static int read_header(antd_client_t* cl, antd_request_t* rq);
static int read_data(antd_client_t* cl, antd_request_t* rq); static int read_data(antd_client_t* cl, antd_request_t* rq);
static void *process(void *data); static void *process(void *data);
static int send_request(antd_client_t *cl, antd_request_t* rq); static int send_request(antd_client_t *cl, antd_request_t* rq);
void* handle(void* data); void* handle(void* data);
static int mk_un_socket(); static int mk_un_socket(fcgi_config_t* config);
static int mk_tcp_socket(); static int mk_tcp_socket(fcgi_config_t* config);
static int read_config() static int read_config(fcgi_config_t* config, antd_plugin_ctx_t* ctx)
{ {
char * tmp; char * tmp;
(void*) memset(g_config.app_bin, 0, MAX_PATH_LEN); (void*) memset(config->app_bin, 0, MAX_PATH_LEN);
(void*) memset(g_config.address, 0, MAX_PATH_LEN); (void*) memset(config->address, 0, MAX_PATH_LEN);
g_config.port = -1; dictionary_t p_config = antd_plugin_config(ctx);
g_config.fd = -1; config->port = -1;
g_config.pid = -1; config->fd = -1;
config->pid = -1;
regmatch_t regex_matches[3]; regmatch_t regex_matches[3];
// read plugin configuration // read plugin configuration
if(!__plugin__.config) if(!p_config)
{ {
PLUGIN_PANIC("No plugin configuration found. Please specify it in server config file"); PLUGIN_PANIC(ctx, "No plugin configuration found. Please specify it in server config file");
return -1; return -1;
} }
tmp = (char*) dvalue(__plugin__.config, "socket"); tmp = (char*) dvalue(p_config, "socket");
if(!tmp) if(!tmp)
{ {
PLUGIN_PANIC("No socket configuration found (socket)"); PLUGIN_PANIC(ctx, "No socket configuration found (socket)");
return -1; return -1;
} }
if(strncmp(tmp,"unix:", 5) == 0) if(strncmp(tmp,"unix:", 5) == 0)
{ {
if(strlen(tmp + 5) > MAX_PATH_LEN - 1) if(strlen(tmp + 5) > MAX_PATH_LEN - 1)
{ {
PLUGIN_PANIC("socket configuration is too long: %s", tmp); PLUGIN_PANIC(ctx, "socket configuration is too long: %s", tmp);
return -1; return -1;
} }
snprintf(g_config.address, MAX_PATH_LEN,"%s", tmp+5); snprintf(config->address, MAX_PATH_LEN,"%s", tmp+5);
LOG("Found Unix domain socket configuration: %s", g_config.address); LOG("Found Unix domain socket configuration: %s", config->address);
} }
else if(regex_match("^([a-zA-Z0-9\\-_\\.]+):([0-9]+)$", tmp,3, regex_matches)) else if(regex_match("^([a-zA-Z0-9\\-_\\.]+):([0-9]+)$", tmp,3, regex_matches))
{ {
if(regex_matches[1].rm_eo - regex_matches[1].rm_so > MAX_PATH_LEN - 1) if(regex_matches[1].rm_eo - regex_matches[1].rm_so > MAX_PATH_LEN - 1)
{ {
PLUGIN_PANIC("socket configuration is too long: %s", tmp); PLUGIN_PANIC(ctx, "socket configuration is too long: %s", tmp);
return -1; return -1;
} }
memcpy(g_config.address, tmp + regex_matches[2].rm_so, regex_matches[2].rm_eo - regex_matches[2].rm_so); memcpy(config->address, tmp + regex_matches[2].rm_so, regex_matches[2].rm_eo - regex_matches[2].rm_so);
g_config.port = atoi(g_config.address); config->port = atoi(config->address);
(void*) memset(g_config.address, 0, MAX_PATH_LEN); (void*) memset(config->address, 0, MAX_PATH_LEN);
memcpy(g_config.address, tmp + regex_matches[1].rm_so, regex_matches[1].rm_eo - regex_matches[1].rm_so); memcpy(config->address, tmp + regex_matches[1].rm_so, regex_matches[1].rm_eo - regex_matches[1].rm_so);
LOG("Found TCP socket configuration: %s:%d", g_config.address, g_config.port); LOG("Found TCP socket configuration: %s:%d", config->address, config->port);
} }
else else
{ {
PLUGIN_PANIC("Unknown socket configuration: %s", tmp); PLUGIN_PANIC(ctx, "Unknown socket configuration: %s", tmp);
return -1; return -1;
} }
tmp = (char*) dvalue(__plugin__.config, "bin"); tmp = (char*) dvalue(p_config, "bin");
if(tmp) if(tmp)
{ {
if(strlen(tmp) > MAX_PATH_LEN - 1) if(strlen(tmp) > MAX_PATH_LEN - 1)
{ {
PLUGIN_PANIC("Bin application configuration is too long: %s", tmp); PLUGIN_PANIC(ctx, "Bin application configuration is too long: %s", tmp);
return -1; return -1;
} }
snprintf(g_config.app_bin, MAX_PATH_LEN,"%s", tmp); snprintf(config->app_bin, MAX_PATH_LEN,"%s", tmp);
LOG("Binary application configuration: %s", g_config.app_bin); LOG("Binary application configuration: %s", config->app_bin);
// create the server socket then launched it // create the server socket then launched it
g_config.fd = mk_socket(); config->fd = mk_socket(config);
if(g_config.fd == -1) if(config->fd == -1)
{ {
PLUGIN_PANIC("Unable to create FastCGI server socket"); PLUGIN_PANIC(ctx, "Unable to create FastCGI server socket");
return -1; return -1;
} }
// launch the application // launch the application
g_config.pid = fork(); config->pid = fork();
if(g_config.pid == -1) if(config->pid == -1)
{ {
PLUGIN_PANIC("Unable to create FastCGI server socket"); PLUGIN_PANIC(ctx, "Unable to create FastCGI server socket");
close(g_config.fd); close(config->fd);
g_config.fd = -1; config->fd = -1;
g_config.pid = -1; config->pid = -1;
return -1; return -1;
} }
if(g_config.pid == 0) if(config->pid == 0)
{ {
// child // child
// close the original stdin // close the original stdin
close(0); close(0);
// redirect the stdin to the socket // redirect the stdin to the socket
dup2(g_config.fd, 0); dup2(config->fd, 0);
char *argv[] = {g_config.app_bin, 0}; char *argv[] = {config->app_bin, 0};
char *env[] = {NULL, NULL}; char *env[] = {NULL, NULL};
env[0] = getenv("ANTD_DEBUG"); env[0] = getenv("ANTD_DEBUG");
if(env[0] && ( if(env[0] && (
@ -162,19 +160,19 @@ static int read_config()
_exit(1); _exit(1);
} }
// parent // parent
LOG("FastCGI process (%d) created", g_config.pid); LOG("FastCGI process (%d) created", config->pid);
} }
return 0; return 0;
} }
static int mk_un_socket() static int mk_un_socket(fcgi_config_t* config)
{ {
struct sockaddr_un address; struct sockaddr_un address;
address.sun_family = AF_UNIX; address.sun_family = AF_UNIX;
//remove socket file if exists //remove socket file if exists
(void) remove(g_config.address); (void) remove(config->address);
// create the socket // create the socket
(void)strncpy(address.sun_path, g_config.address, sizeof(address.sun_path)); (void)strncpy(address.sun_path, config->address, sizeof(address.sun_path));
int fd = socket(AF_UNIX, SOCK_STREAM, 0); int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) if (fd == -1)
{ {
@ -191,14 +189,14 @@ static int mk_un_socket()
if (listen(fd, MAX_BACK_LOG) == -1) if (listen(fd, MAX_BACK_LOG) == -1)
{ {
ERROR("Unable to listen to socket: %d (%s): %s", fd, g_config.address, strerror(errno)); ERROR("Unable to listen to socket: %d (%s): %s", fd, config->address, strerror(errno));
close(fd); close(fd);
return -1; return -1;
} }
LOG("Socket %s is created successfully: %d", g_config.address, fd); LOG("Socket %s is created successfully: %d", config->address, fd);
return fd; return fd;
} }
static int mk_tcp_socket() static int mk_tcp_socket(fcgi_config_t* config)
{ {
int fd = -1; int fd = -1;
struct sockaddr_in name; struct sockaddr_in name;
@ -211,35 +209,35 @@ static int mk_tcp_socket()
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int)) == -1) if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &(int){1}, sizeof(int)) == -1)
{ {
ERROR("Unable to set reuse address on port %d - setsockopt: %s", g_config.port, strerror(errno)); ERROR("Unable to set reuse address on port %d - setsockopt: %s", config->port, strerror(errno));
} }
memset(&name, 0, sizeof(name)); memset(&name, 0, sizeof(name));
name.sin_family = AF_INET; name.sin_family = AF_INET;
name.sin_port = htons(g_config.port); name.sin_port = htons(config->port);
name.sin_addr.s_addr = htonl(INADDR_ANY); name.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(fd, (struct sockaddr *)&name, sizeof(name)) < 0) if (bind(fd, (struct sockaddr *)&name, sizeof(name)) < 0)
{ {
ERROR("Unable to bind TCP socket at port %d -bind: %s", g_config.port, strerror(errno)); ERROR("Unable to bind TCP socket at port %d -bind: %s", config->port, strerror(errno));
close(fd); close(fd);
return -1; return -1;
} }
if (listen(fd, MAX_BACK_LOG) < 0) if (listen(fd, MAX_BACK_LOG) < 0)
{ {
ERROR("Unable to listen on Port %d - listen: %s", g_config.port, strerror(errno)); ERROR("Unable to listen on Port %d - listen: %s", config->port, strerror(errno));
close(fd); close(fd);
return -1; return -1;
} }
return fd; return fd;
} }
static int open_un_socket() static int open_un_socket(fcgi_config_t* config)
{ {
struct sockaddr_un address; struct sockaddr_un address;
address.sun_family = AF_UNIX; address.sun_family = AF_UNIX;
// create the socket // create the socket
(void)strncpy(address.sun_path, g_config.address, sizeof(address.sun_path)); (void)strncpy(address.sun_path, config->address, sizeof(address.sun_path));
int fd = socket(AF_UNIX, SOCK_STREAM, 0); int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd == -1) if (fd == -1)
{ {
@ -252,17 +250,17 @@ static int open_un_socket()
close(fd); close(fd);
return -1; return -1;
} }
LOG("Connected to FastCGI server at %s: %d", g_config.address, fd); LOG("Connected to FastCGI server at %s: %d", config->address, fd);
return fd; return fd;
} }
static int open_tcp_socket() static int open_tcp_socket(fcgi_config_t* config)
{ {
struct sockaddr_in servaddr; struct sockaddr_in servaddr;
int fd = socket(AF_INET, SOCK_STREAM, 0); int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) if (fd == -1)
{ {
PLUGIN_PANIC("Cannot create TCP socket %s:d: %s",g_config.address, g_config.port, strerror(errno)); ERROR("Cannot create TCP socket %s:%d: %s",config->address, config->port, strerror(errno));
return -1; return -1;
} }
@ -270,68 +268,76 @@ static int open_tcp_socket()
// assign IP, PORT // assign IP, PORT
servaddr.sin_family = AF_INET; servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(g_config.address); servaddr.sin_addr.s_addr = inet_addr(config->address);
servaddr.sin_port = htons(g_config.port); servaddr.sin_port = htons(config->port);
// connect the client socket to server socket // connect the client socket to server socket
if (connect(fd, (struct sockaddr*)&servaddr, sizeof(servaddr))!= 0) { if (connect(fd, (struct sockaddr*)&servaddr, sizeof(servaddr))!= 0) {
ERROR( "Unable to connect to socket '%s:%d': %s", g_config.address, g_config.port, strerror(errno)); ERROR( "Unable to connect to socket '%s:%d': %s", config->address, config->port, strerror(errno));
close(fd); close(fd);
return -1; return -1;
} }
LOG("Connected to server: %s:%d at [%d]", g_config.address, g_config.port, fd); LOG("Connected to server: %s:%d at [%d]", config->address, config->port, fd);
return fd; return fd;
} }
static int open_socket() static int open_socket(fcgi_config_t* config)
{ {
if(g_config.port != -1) if(config->port != -1)
{ {
return open_tcp_socket(); return open_tcp_socket(config);
} }
else else
{ {
return open_un_socket(); return open_un_socket(config);
} }
} }
static int mk_socket() static int mk_socket(fcgi_config_t* config)
{ {
if(g_config.port != -1) if(config->port != -1)
{ {
return mk_tcp_socket(); return mk_tcp_socket(config);
} }
else else
{ {
return mk_un_socket(); return mk_un_socket(config);
} }
} }
void init() void* create(antd_plugin_ctx_t* ctx)
{ {
use_raw_body(); fcgi_config_t* conf = (fcgi_config_t*) malloc(sizeof(fcgi_config_t));
if(read_config() != 0) if(!conf)
return; {
// create the socket PLUGIN_PANIC(ctx, "Unable to allocate memory for plugin config");
//if(create_socket() != 0) return NULL;
// return; }
antd_plugin_use_raw_body(ctx);
if(read_config(conf, ctx) != 0)
{
free(conf);
return NULL;
}
LOG("FastCGI init successful"); LOG("FastCGI init successful");
return conf;
} }
void destroy() void drop(antd_plugin_ctx_t* ctx)
{ {
if(g_config.pid > 0) fcgi_config_t* config = (fcgi_config_t*)antd_plugin_data(ctx);
if(config->pid > 0)
{ {
LOG("Process killed: %d", g_config.pid); LOG("Process killed: %d", config->pid);
(void)kill(g_config.pid, SIGKILL); (void)kill(config->pid, SIGKILL);
g_config.pid = -1; config->pid = -1;
} }
if(g_config.fd > 0) if(config->fd > 0)
{ {
LOG("Close server socket: %d", g_config.fd); LOG("Close server socket: %d", config->fd);
close(g_config.fd); close(config->fd);
g_config.fd = -1; config->fd = -1;
} }
free(config);
} }
@ -515,14 +521,21 @@ static int read_data(antd_client_t* cl, antd_request_t* rq)
static void *process(void *data) static void *process(void *data)
{ {
antd_request_t *rq = (antd_request_t *)data; antd_request_t *rq = (antd_request_t *)data;
antd_plugin_ctx_t* ctx = rq->context;
fcgi_config_t* config = antd_plugin_data(ctx);
antd_client_t* cl = (antd_client_t* ) dvalue(rq->request, "FCGI_CL_DATA"); antd_client_t* cl = (antd_client_t* ) dvalue(rq->request, "FCGI_CL_DATA");
struct pollfd pfds[2]; struct pollfd pfds[2];
int status; int status;
if(g_config.pid > 0) if(config == NULL)
{ {
if(waitpid(g_config.pid, &status, WNOHANG) > 0) PLUGIN_PANIC(ctx, "No plugin context configuration found");
return antd_create_task(NULL, data, NULL, rq->client->last_io);
}
if(config->pid > 0)
{ {
PLUGIN_PANIC("FastCGI process exits unexpectedly"); if(waitpid(config->pid, &status, WNOHANG) > 0)
{
PLUGIN_PANIC(ctx, "FastCGI process exits unexpectedly");
antd_close(cl); antd_close(cl);
dput(rq->request, "FCGI_CL_DATA", NULL); dput(rq->request, "FCGI_CL_DATA", NULL);
return antd_create_task(NULL, data, NULL, rq->client->last_io); return antd_create_task(NULL, data, NULL, rq->client->last_io);
@ -647,13 +660,13 @@ static int send_request(antd_client_t *cl, antd_request_t* rq)
char *tmp = NULL; char *tmp = NULL;
char *root; char *root;
dictionary_t request = (dictionary_t)rq->request; dictionary_t request = (dictionary_t)rq->request;
antd_plugin_ctx_t* ctx = rq->context;
dictionary_t header = (dictionary_t)dvalue(rq->request, "REQUEST_HEADER"); dictionary_t header = (dictionary_t)dvalue(rq->request, "REQUEST_HEADER");
ret += fcgi_begin_request(cl, cl->sock, FCGI_RESPONDER, 0); ret += fcgi_begin_request(cl, cl->sock, FCGI_RESPONDER, 0);
//ret += fcgi_send_param(cl, cl->sock, "", ""); //ret += fcgi_send_param(cl, cl->sock, "", "");
// ANTD specific params // ANTD specific params
ret += fcgi_send_param(cl, cl->sock, "TMP_DIR", __plugin__.tmpdir); ret += fcgi_send_param(cl, cl->sock, "TMP_DIR", antd_plugin_tmpdir(ctx));
ret += fcgi_send_param(cl, cl->sock, "DB_DIR", __plugin__.dbpath); ret += fcgi_send_param(cl, cl->sock, "LIB_DIR", antd_plugin_basedir(ctx));
ret += fcgi_send_param(cl, cl->sock, "LIB_DIR", __plugin__.pdir);
// CGI parms // CGI parms
ret += fcgi_send_param(cl, cl->sock, "GATEWAY_INTERFACE", "CGI/1.1"); ret += fcgi_send_param(cl, cl->sock, "GATEWAY_INTERFACE", "CGI/1.1");
ret += fcgi_send_param(cl, cl->sock, "SERVER_SOFTWARE", SERVER_NAME); ret += fcgi_send_param(cl, cl->sock, "SERVER_SOFTWARE", SERVER_NAME);
@ -758,8 +771,15 @@ static int send_request(antd_client_t *cl, antd_request_t* rq)
void* handle(void* data) void* handle(void* data)
{ {
antd_request_t *rq = (antd_request_t *)data; antd_request_t *rq = (antd_request_t *)data;
antd_plugin_ctx_t* ctx = rq->context;
fcgi_config_t* conf = antd_plugin_data(ctx);
if(conf == NULL)
{
PLUGIN_PANIC(ctx, "No plugin context configuration found");
return antd_create_task(NULL, data, NULL, rq->client->last_io);
}
// connect to socket // connect to socket
int fd = open_socket(); int fd = open_socket(conf);
if(fd < 0) if(fd < 0)
{ {
antd_error(rq->client, 503, "Service unavailable"); antd_error(rq->client, 503, "Service unavailable");

16
proto.c
View File

@ -64,7 +64,7 @@ static int fcgi_send_record(antd_client_t* cl, FCGI_Header* header, uint8_t* buf
int ret = antd_send(cl, (uint8_t*)header, sizeof(FCGI_Header)); int ret = antd_send(cl, (uint8_t*)header, sizeof(FCGI_Header));
if(ret != sizeof(FCGI_Header)) if(ret != sizeof(FCGI_Header))
{ {
ERROR("fcgi_send_record: Unable to send record header, only %d of %d bytes sent: %s", ret, sizeof(FCGI_Header), strerror(errno)); ERROR("fcgi_send_record: Unable to send record header, only %d of %lu bytes sent: %s", ret, sizeof(FCGI_Header), strerror(errno));
return -1; return -1;
} }
if(!buff) if(!buff)
@ -75,7 +75,7 @@ static int fcgi_send_record(antd_client_t* cl, FCGI_Header* header, uint8_t* buf
ret = antd_send(cl, (uint8_t*)buff, len); ret = antd_send(cl, (uint8_t*)buff, len);
if(ret != (int)len) if(ret != (int)len)
{ {
ERROR("fcgi_send_record: Unable to send record data, only %d of %d bytes sent", ret, len); ERROR("fcgi_send_record: Unable to send record data, only %d of %d bytes sent", ret, (int)len);
return -1; return -1;
} }
return 0; return 0;
@ -84,6 +84,7 @@ static int fcgi_send_record(antd_client_t* cl, FCGI_Header* header, uint8_t* buf
int fcgi_begin_request(antd_client_t* cl, uint16_t id, uint16_t role, uint8_t flags) int fcgi_begin_request(antd_client_t* cl, uint16_t id, uint16_t role, uint8_t flags)
{ {
FCGI_BeginRequestRecord record; FCGI_BeginRequestRecord record;
memset(&record, 0, sizeof(record));
record.header.version = FCGI_VERSION_1; record.header.version = FCGI_VERSION_1;
record.header.type = FCGI_BEGIN_REQUEST; record.header.type = FCGI_BEGIN_REQUEST;
record.header.requestIdB1 = id >> 8; record.header.requestIdB1 = id >> 8;
@ -99,7 +100,7 @@ int fcgi_begin_request(antd_client_t* cl, uint16_t id, uint16_t role, uint8_t fl
int ret = antd_send(cl, (uint8_t*)&record, sizeof(record)); int ret = antd_send(cl, (uint8_t*)&record, sizeof(record));
if(ret != sizeof(record)) if(ret != sizeof(record))
{ {
ERROR("fcgi_begin_request: Unable to send record data, only %d of %d bytes sent", ret, sizeof(record)); ERROR("fcgi_begin_request: Unable to send record data, only %d of %lu bytes sent", ret, sizeof(record));
return -1; return -1;
} }
return 0; return 0;
@ -108,6 +109,7 @@ int fcgi_begin_request(antd_client_t* cl, uint16_t id, uint16_t role, uint8_t fl
int fcgi_abort_request(antd_client_t* cl, uint16_t id) int fcgi_abort_request(antd_client_t* cl, uint16_t id)
{ {
FCGI_Header header; FCGI_Header header;
memset(&header, 0, sizeof(header));
header.version = FCGI_VERSION_1; header.version = FCGI_VERSION_1;
header.type = FCGI_BEGIN_REQUEST; header.type = FCGI_BEGIN_REQUEST;
header.requestIdB1 = id >> 8; header.requestIdB1 = id >> 8;
@ -118,7 +120,7 @@ int fcgi_abort_request(antd_client_t* cl, uint16_t id)
int ret = antd_send(cl, (uint8_t*)&header, sizeof(header)); int ret = antd_send(cl, (uint8_t*)&header, sizeof(header));
if(ret != sizeof(header)) if(ret != sizeof(header))
{ {
ERROR("fcgi_abort_request: Unable to send record data, only %d of %d bytes sent", ret, sizeof(header)); ERROR("fcgi_abort_request: Unable to send record data, only %d of %lu bytes sent", ret, sizeof(header));
return -1; return -1;
} }
return 0; return 0;
@ -137,6 +139,7 @@ int fcgi_send_param(antd_client_t* cl, int id, const char* key, const char* valu
size_t max_buff_len = sizeof(FCGI_Params_Body) + k_length + v_length + 8; size_t max_buff_len = sizeof(FCGI_Params_Body) + k_length + v_length + 8;
buff = (uint8_t*)malloc(max_buff_len); buff = (uint8_t*)malloc(max_buff_len);
memset(buff, 0, max_buff_len);
if(!buff) if(!buff)
{ {
ERROR("Unable to allocate PARAMS record buffer memory: %s", strerror(errno)); ERROR("Unable to allocate PARAMS record buffer memory: %s", strerror(errno));
@ -147,6 +150,7 @@ int fcgi_send_param(antd_client_t* cl, int id, const char* key, const char* valu
body = (FCGI_Params_Body*) buff; body = (FCGI_Params_Body*) buff;
FCGI_Header header; FCGI_Header header;
memset(&header, 0, sizeof(header));
header.version = FCGI_VERSION_1; header.version = FCGI_VERSION_1;
header.type = FCGI_PARAMS; header.type = FCGI_PARAMS;
header.requestIdB1 = id >> 8; header.requestIdB1 = id >> 8;
@ -221,6 +225,7 @@ int fcgi_send_param(antd_client_t* cl, int id, const char* key, const char* valu
int fcgi_send_stdin(antd_client_t* cl, int id, uint8_t* padded_data, size_t len, uint8_t paddlen) int fcgi_send_stdin(antd_client_t* cl, int id, uint8_t* padded_data, size_t len, uint8_t paddlen)
{ {
FCGI_Header header; FCGI_Header header;
memset(&header, 0, sizeof(header));
header.version = FCGI_VERSION_1; header.version = FCGI_VERSION_1;
header.type = FCGI_STDIN; header.type = FCGI_STDIN;
header.requestIdB1 = id >> 8; header.requestIdB1 = id >> 8;
@ -228,6 +233,7 @@ int fcgi_send_stdin(antd_client_t* cl, int id, uint8_t* padded_data, size_t len,
header.contentLengthB1 = len >> 8; header.contentLengthB1 = len >> 8;
header.contentLengthB0 = len & 0xFF; header.contentLengthB0 = len & 0xFF;
header.paddingLength = paddlen; header.paddingLength = paddlen;
header.reserved = 0;
// send the record // send the record
return fcgi_send_record(cl, &header, padded_data, len + paddlen); return fcgi_send_record(cl, &header, padded_data, len + paddlen);
} }
@ -239,7 +245,7 @@ int fcgi_read_header(antd_client_t* cl, FCGI_Header* header)
int ret = antd_recv(cl, buff, sizeof(FCGI_Header)); int ret = antd_recv(cl, buff, sizeof(FCGI_Header));
if(ret != sizeof(FCGI_Header)) if(ret != sizeof(FCGI_Header))
{ {
ERROR("Unable to read header: received %d bytes out of %d bytes", ret, sizeof(FCGI_Header)); ERROR("Unable to read header: received %d bytes out of %lu bytes", ret, sizeof(FCGI_Header));
return -1; return -1;
} }
return 0; return 0;

2
proto.h
View File

@ -1,7 +1,7 @@
#ifndef PROTO_H #ifndef PROTO_H
#define PROTO_H #define PROTO_H
#include <unistd.h> #include <unistd.h>
#include <antd/plugin.h> #include <antd/handle.h>
/* /*
* Listening socket file number * Listening socket file number
*/ */