text: /*
   * http_server - HTTP server
   * Copyright (c) 2009, Jouni Malinen <j@w1.fi>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License version 2 as
   * published by the Free Software Foundation.
   *
   * Alternatively, this software may be distributed under the terms of BSD
   * license.
   *
   * See README and COPYING for more details.
   */
  
  #include "includes.h"
  #include <fcntl.h>
  
  #include "common.h"
  #include "eloop.h"
  #include "httpread.h"
  #include "http_server.h"
  
  #define HTTP_SERVER_TIMEOUT 30
  #define HTTP_SERVER_MAX_REQ_LEN 8000
  #define HTTP_SERVER_MAX_CONNECTIONS 10
  
  struct http_request {
  	struct http_request *next;
  	struct http_server *srv;
  	int fd;
  	struct sockaddr_in cli;
  	struct httpread *hread;
  };
  
  struct http_server {
  	void (*cb)(void *ctx, struct http_request *req);
  	void *cb_ctx;
  
  	int fd;
  	int port;
  
  	struct http_request *requests;
  	unsigned int request_count;
  };
  
  
  static void http_request_cb(struct httpread *handle, void *cookie,
  			    enum httpread_event en)
  {
  	struct http_request *req = cookie;
  	struct http_server *srv = req->srv;
  
  	if (en == HTTPREAD_EVENT_FILE_READY) {
  		wpa_printf(MSG_DEBUG, "HTTP: Request from %s:%d received",
  			   inet_ntoa(req->cli.sin_addr),
  			   ntohs(req->cli.sin_port));
  		srv->cb(srv->cb_ctx, req);
  		return;
  	}
  	wpa_printf(MSG_DEBUG, "HTTP: Request from %s:%d could not be received "
  		   "completely", inet_ntoa(req->cli.sin_addr),
  		   ntohs(req->cli.sin_port));
  	http_request_deinit(req);
  }
  
  
  static struct http_request * http_request_init(struct http_server *srv, int fd,
  					       struct sockaddr_in *cli)
  {
  	struct http_request *req;
  
  	if (srv->request_count >= HTTP_SERVER_MAX_CONNECTIONS) {
  		wpa_printf(MSG_DEBUG, "HTTP: Too many concurrent requests");
  		return NULL;
  	}
  
  	req = os_zalloc(sizeof(*req));
  	if (req == NULL)
  		return NULL;
  
  	req->srv = srv;
  	req->fd = fd;
  	req->cli = *cli;
  
  	req->hread = httpread_create(req->fd, http_request_cb, req,
  				     HTTP_SERVER_MAX_REQ_LEN,
  				     HTTP_SERVER_TIMEOUT);
  	if (req->hread == NULL) {
  		http_request_deinit(req);
  		return NULL;
  	}
  
  	return req;
  }
  
  
  void http_request_deinit(struct http_request *req)
  {
  	struct http_request *r, *p;
  	struct http_server *srv;
  
  	if (req == NULL)
  		return;
  
  	srv = req->srv;
  	p = NULL;
  	r = srv->requests;
  	while (r) {
  		if (r == req) {
  			if (p)
  				p->next = r->next;
  			else
  				srv->requests = r->next;
  			srv->request_count--;
  			break;
  		}
  		p = r;
  		r = r->next;
  	}
  
  	httpread_destroy(req->hread);
  	close(req->fd);
  	os_free(req);
  }
  
  
  static void http_request_free_all(struct http_request *req)
  {
  	struct http_request *prev;
  	while (req) {
  		prev = req;
  		req = req->next;
  		http_request_deinit(prev);
  	}
  }
  
  
  void http_request_send(struct http_request *req, struct wpabuf *resp)
  {
  	int res;
  
  	wpa_printf(MSG_DEBUG, "HTTP: Send %lu byte response to %s:%d",
  		   (unsigned long) wpabuf_len(resp),
  		   inet_ntoa(req->cli.sin_addr),
  		   ntohs(req->cli.sin_port));
  
  	res = send(req->fd, wpabuf_head(resp), wpabuf_len(resp), 0);
  	if (res < 0) {
  		wpa_printf(MSG_DEBUG, "HTTP: Send failed: %s",
  			   strerror(errno));
  	} else if ((size_t) res < wpabuf_len(resp)) {
  		wpa_printf(MSG_DEBUG, "HTTP: Sent only %d of %lu bytes",
  			   res, (unsigned long) wpabuf_len(resp));
  		/* TODO: add eloop handler for sending rest of the data */
  	}
  
  	wpabuf_free(resp);
  }
  
  
  void http_request_send_and_deinit(struct http_request *req,
  				  struct wpabuf *resp)
  {
  	http_request_send(req, resp);
  	http_request_deinit(req);
  }
  
  
  enum httpread_hdr_type http_request_get_type(struct http_request *req)
  {
  	return httpread_hdr_type_get(req->hread);
  }
  
  
  char * http_request_get_uri(struct http_request *req)
  {
  	return httpread_uri_get(req->hread);
  }
  
  
  char * http_request_get_hdr(struct http_request *req)
  {
  	return httpread_hdr_get(req->hread);
  }
  
  
  char * http_request_get_data(struct http_request *req)
  {
  	return httpread_data_get(req->hread);
  }
  
  
  char * http_request_get_hdr_line(struct http_request *req, const char *tag)
  {
  	return httpread_hdr_line_get(req->hread, tag);
  }
  
  
  struct sockaddr_in * http_request_get_cli_addr(struct http_request *req)
  {
  	return &req->cli;
  }
  
  
  static void http_server_cb(int sd, void *eloop_ctx, void *sock_ctx)
  {
  	struct sockaddr_in addr;
  	socklen_t addr_len = sizeof(addr);
  	struct http_server *srv = eloop_ctx;
  	int conn;
  	struct http_request *req;
  
  	conn = accept(srv->fd, (struct sockaddr *) &addr, &addr_len);
  	if (conn < 0) {
  		wpa_printf(MSG_DEBUG, "HTTP: Failed to accept new connection: "
  			   "%s", strerror(errno));
  		return;
  	}
  	wpa_printf(MSG_DEBUG, "HTTP: Connection from %s:%d",
  		   inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
  
  	req = http_request_init(srv, conn, &addr);
  	if (req == NULL) {
  		close(conn);
  		return;
  	}
  
  	req->next = srv->requests;
  	srv->requests = req;
  	srv->request_count++;
  }
  
  
  struct http_server * http_server_init(struct in_addr *addr, int port,
  				      void (*cb)(void *ctx,
  						 struct http_request *req),
  				      void *cb_ctx)
  {
  	struct sockaddr_in sin;
  	struct http_server *srv;
  
  	srv = os_zalloc(sizeof(*srv));
  	if (srv == NULL)
  		return NULL;
  	srv->cb = cb;
  	srv->cb_ctx = cb_ctx;
  
  	srv->fd = socket(AF_INET, SOCK_STREAM, 0);
  	if (srv->fd < 0)
  		goto fail;
  	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
  		goto fail;
  	if (port < 0)
  		srv->port = 49152;
  	else
  		srv->port = port;
  
  	os_memset(&sin, 0, sizeof(sin));
  	sin.sin_family = AF_INET;
  	sin.sin_addr.s_addr = addr->s_addr;
  
  	for (;;) {
  		sin.sin_port = htons(srv->port);
  		if (bind(srv->fd, (struct sockaddr *) &sin, sizeof(sin)) == 0)
  			break;
  		if (errno == EADDRINUSE) {
  			/* search for unused port */
  			if (++srv->port == 65535 || port >= 0)
  				goto fail;
  			continue;
  		}
  		wpa_printf(MSG_DEBUG, "HTTP: Failed to bind server port %d: "
  			   "%s", srv->port, strerror(errno));
  		goto fail;
  	}
  	if (listen(srv->fd, 10 /* max backlog */) < 0)
  		goto fail;
  	if (fcntl(srv->fd, F_SETFL, O_NONBLOCK) < 0)
  		goto fail;
  	if (eloop_register_sock(srv->fd, EVENT_TYPE_READ, http_server_cb,
  				srv, NULL))
  		goto fail;
  
  	wpa_printf(MSG_DEBUG, "HTTP: Started server on %s:%d",
  		   inet_ntoa(*addr), srv->port);
  
  	return srv;
  
  fail:
  	http_server_deinit(srv);
  	return NULL;
  }
  
  
  void http_server_deinit(struct http_server *srv)
  {
  	if (srv == NULL)
  		return;
  	if (srv->fd >= 0) {
  		eloop_unregister_sock(srv->fd, EVENT_TYPE_READ);
  		close(srv->fd);
  	}
  	http_request_free_all(srv->requests);
  
  	os_free(srv);
  }
  
  
  int http_server_get_port(struct http_server *srv)
  {
  	return srv->port;
  }
  