static int
server_exec_cmd(int sock, char *cmd)
{
int argc = 0;
char *argv[MAXARGS];
char *save, *p, *nil;
server_function_t *sf;
int r;
log_debug("server_exec_cmd: %s", cmd);
for (nil = cmd; (p = strtok_r(nil, " ", &save)) && argc < MAXARGS; nil = NULL, ++argc)
{
argv[argc] = p;
}
if (argc == MAXARGS)
{
server_reply(sock, "Too many arguments");
log_error("server_exec_cmd: Too many arguments");
return -1;
}
sf = sht_lookup(&server_function_table, argv[0]);
if (sf == NULL)
{
sf = sht_lookup(&server_function_table, "help");
if (sf == NULL)
{
log_die(EX_SOFTWARE, "server_exec_cmd: help not found. This is impossible hence fatal.");
}
}
r = sf->sf_callback(sock, argc, argv);
switch (r)
{
case 0:
server_reply(sock, "CLOSE");
break;
case -1:
log_error("server_exec_cmd: %s failed", argv[0]);
server_reply(sock, "ERROR");
break;
default:
server_ok(sock);
break;
}
return r;
}
int
server_data_cmd(int sock, char *cmd, char **buffer)
{
char recv[RECV_BUFFER];
int n, size, completed;
log_debug("server_data_cmd: command '%s'", cmd);
if (server_reply(sock, cmd) == -1)
{
log_error("server_data_cmd: server_reply failed");
return -1;
}
n = read(sock, recv, sizeof recv);
if (n == -1)
{
log_sys_error("server_data_cmd: read");
return -1;
}
size = atoi(recv);
if (size < 0 || size > MAX_BUFFER)
{
log_error("server_data_cmd: bad buffer size");
return -1;
}
*buffer = (char *) malloc(size + 1);
if (*buffer == NULL)
{
log_sys_error("server_data_cmd: malloc");
return -1;
}
if (server_ok(sock))
{
log_error("server_data_cmd: server_ok failed");
return -1;
}
for (completed = 0; size > completed; completed += n)
{
n = read(sock, *buffer + completed, size - completed);
if (n == -1)
{
log_sys_error("server_data_cmd: read");
return -1;
}
}
(*buffer)[completed] = 0;
if (server_check(sock))
{
log_error("server_data_cmd: server_check failed");
return -1;
}
return 0;
}
static int
server_output(int sock, char *buffer, int size)
{
int n;
if (server_reply(sock, "%d", size) == -1)
{
log_error("server_output: server_reply failed");
return -1;
}
if (server_check(sock))
{
log_error("server_output: server_check failed");
return -1;
}
n = write(sock, buffer, size);
if (n == -1)
{
log_sys_error("server_output: write");
return -1;
}
return n;
}
int
server_help(int sock, int argc, char **argv)
{
server_function_t *func;
char buffer[RECV_BUFFER];
if (strncmp(argv[0], "help", 4))
{
server_reply(sock, "Unknown command");
}
server_reply(sock, "HELP:");
for (func = server_functions; func->sf_name; ++func)
{
util_concat(buffer, sizeof buffer, func->sf_name, "\t", func->sf_help, NULL);
server_reply(sock, buffer);
}
return 1;
}
int
server_greylist_pass(int sock, int argc, char **argv)
{
if (argc != 4)
{
server_reply(sock, "Usage: %s source from rcpt", argv[0]);
return -1;
}
switch(greylist_pass(argv[1], argv[2], argv[3]))
{
case -1:
log_error("server_greylist_pass: greylist_pass failed");
return -1;
case 0:
server_reply(sock, "Not found");
default:
break;
}
return 1;
}
int main(){
lib_init();
socket_t * serverSocket = socket_new();
socket_bind(serverSocket, 5000);
socket_listen(serverSocket);
film_maker_t* film_makers[FILM_MAKERS_AMOUNT];
for (int i = 0; i < FILM_MAKERS_AMOUNT; i++) {
film_makers[i] = film_maker_new();
}
parse(film_makers,"XML_format.xml");
while(1) {
socket_t * clientSocket = socket_accept(serverSocket);
char buf[102400];
if(socket_read(clientSocket, buf, 102400) == 0) {
socket_close(clientSocket);
socket_free(clientSocket);
puts("Skipping empty request");
continue;
}
http_request_t req = http_request_parse(buf);
server_reply(clientSocket, req, film_makers);
//puts("fghj");
socket_close(clientSocket);
socket_free(clientSocket);
}
for (int i = 0; i < 3; i++)
film_maker_free(film_makers[i]);
socket_close(serverSocket);
socket_free(serverSocket);
lib_free();
return 0;
}
int
server_cmd(int sock, char *cmd)
{
log_debug("server_cmd: command '%s'", cmd);
if (server_reply(sock, cmd) == -1)
{
log_error("server_data_cmd: server_reply failed");
return -1;
}
if (server_check(sock))
{
log_sys_error("server_data_cmd: server_check failed");
return -1;
}
return 0;
}
int main()
{
lib_init();
socket_t * server = socket_new();
socket_bind(server, 5000);
socket_listen(server);
char buf[10000];
char pathBuf[256];
socket_t * client = NULL;
while(1)
{
client = socket_accept(server);
socket_read(client, buf, sizeof(buf));
http_request_t rs;
rs = http_request_parse(buf);
server_reply(client,rs);
}
socket_free(server);
socket_free(client);
lib_free();
return 0;
}
/** Process incoming request message */
static
void server_request(server_t *srv,
tport_t *tport,
msg_t *request,
void *arg,
su_time_t now)
{
nth_site_t *site = NULL, *subsite = NULL;
msg_t *response;
http_t *http = http_object(request);
http_host_t *h;
char const *host, *port, *path, *subpath = NULL;
/* Disable streaming */
if (msg_is_streaming(request)) {
msg_set_streaming(request, (enum msg_streaming_status)0);
return;
}
/* Create a response message */
response = server_msg_create(srv, 0, NULL, 0, NULL, NULL);
tport_tqueue(tport, response, TAG_END());
if (http && http->http_flags & MSG_FLG_TIMEOUT) {
server_reply(srv, tport, request, response, 400, "Request timeout");
return;
} else if (http && http->http_flags & MSG_FLG_TOOLARGE) {
server_reply(srv, tport, request, response, HTTP_413_ENTITY_TOO_LARGE);
return;
} else if (!http || !http->http_request ||
(http->http_flags & MSG_FLG_ERROR)) {
server_reply(srv, tport, request, response, HTTP_400_BAD_REQUEST);
return;
}
if (http->http_request->rq_version != http_version_1_0 &&
http->http_request->rq_version != http_version_1_1) {
server_reply(srv, tport, request, response, HTTP_505_HTTP_VERSION);
return;
}
h = http->http_host;
if (h) {
host = h->h_host, port = h->h_port;
}
else if (http->http_request->rq_url->url_host) {
host = http->http_request->rq_url->url_host;
port = http->http_request->rq_url->url_port;
}
else
host = NULL, port = NULL;
path = http->http_request->rq_url->url_path;
if (host)
site = *site_get_host(&srv->srv_sites, host, port);
if (site == NULL && !srv->srv_sites->site_strict)
site = srv->srv_sites;
if (path == NULL)
path = "";
if (path[0])
subsite = site_get_subdir(site, path, &subpath);
if (subsite)
subsite->site_access = now;
else
site->site_access = now;
if (subsite && subsite->site_isdir && subpath == site_nodir_match) {
/* Answer with 301 */
http_location_t loc[1];
http_location_init(loc);
*loc->loc_url = *site->site_url;
if (site->site_wildcard) {
if (http->http_host) {
loc->loc_url->url_host = http->http_host->h_host;
loc->loc_url->url_port = http->http_host->h_port;
}
else {
tp_name_t const *tpn = tport_name(tport); assert(tpn);
loc->loc_url->url_host = tpn->tpn_canon;
if (strcmp(url_port_default((enum url_type_e)loc->loc_url->url_type), tpn->tpn_port))
loc->loc_url->url_port = tpn->tpn_port;
}
}
loc->loc_url->url_root = 1;
loc->loc_url->url_path = subsite->site_url->url_path;
msg_header_add_dup(response, NULL, (msg_header_t *)loc);
server_reply(srv, tport, request, response, HTTP_301_MOVED_PERMANENTLY);
}
else if (subsite)
nth_site_request(srv, subsite, tport, request, http, subpath, response);
else if (site)
nth_site_request(srv, site, tport, request, http, path, response);
else
/* Answer with 404 */
server_reply(srv, tport, request, response, HTTP_404_NOT_FOUND);
}
static
void nth_site_request(server_t *srv,
nth_site_t *site,
tport_t *tport,
msg_t *request,
http_t *http,
char const *path,
msg_t *response)
{
auth_mod_t *am = site->site_auth;
nth_request_t *req;
auth_status_t *as;
struct auth_info *ai;
size_t size = (am ? (sizeof *as) + (sizeof *ai) : 0) + (sizeof *req);
int status;
req = su_zalloc(srv->srv_home, size);
if (req == NULL) {
server_reply(srv, tport, request, response, HTTP_500_INTERNAL_SERVER);
return;
}
if (am)
as = auth_status_init(req + 1, sizeof *as), ai = (void *)(as + 1);
else
as = NULL, ai = NULL;
req->req_server = srv;
req->req_method = http->http_request->rq_method;
req->req_method_name = http->http_request->rq_method_name;
req->req_url = http->http_request->rq_url;
req->req_version = http->http_request->rq_version;
req->req_tport = tport_incref(tport);
req->req_request = request;
req->req_response = response;
req->req_status = 100;
req->req_close =
!srv->srv_persistent
|| http->http_request->rq_version != http_version_1_1
|| (http->http_connection &&
msg_params_find(http->http_connection->k_items, "close"));
if (am) {
static auth_challenger_t const http_server_challenger[] =
{{ HTTP_401_UNAUTHORIZED, http_www_authenticate_class }};
req->req_as = as;
as->as_method = http->http_request->rq_method_name;
as->as_uri = path;
if (http->http_payload) {
as->as_body = http->http_payload->pl_data;
as->as_bodylen = http->http_payload->pl_len;
}
auth_mod_check_client(am, as,
http->http_authorization,
http_server_challenger);
if (as->as_status == 100) {
/* Stall transport - do not read more requests */
if (tport_queuelen(tport) * 2 >= srv->srv_queuesize)
tport_stall(tport);
as->as_callback = nth_authentication_result;
as->as_magic = ai;
ai->site = site;
ai->req = req;
ai->http = http;
ai->path = path;
return;
}
else if (as->as_status) {
assert(as->as_status >= 200);
nth_request_treply(req, as->as_status, as->as_phrase,
HTTPTAG_HEADER((http_header_t *)as->as_response),
HTTPTAG_HEADER((http_header_t *)as->as_info),
TAG_END());
nth_request_destroy(req);
return;
}
}
req->req_in_callback = 1;
status = site->site_callback(site->site_magic, site, req, http, path);
req->req_in_callback = 0;
if (status != 0 && (status < 100 || status >= 600))
status = 500;
if (status != 0 && req->req_status < 200) {
nth_request_treply(req, status, NULL, TAG_END());
}
if (req->req_status < 100) {
/* Stall transport - do not read more requests */
if (tport_queuelen(tport) * 2 >= srv->srv_queuesize)
tport_stall(tport);
}
if (status >= 200 || req->req_destroyed)
nth_request_destroy(req);
}
