Esempio n. 1
0
File: HTTPd.c Progetto: Youx/craftd
static
void
cd_JSONRequest (struct evhttp_request* request, CDServer* server)
{
    struct evbuffer* buffer = evhttp_request_get_input_buffer(request);
    char*            text   = CD_alloc(evbuffer_get_length(buffer) + 1);

    evbuffer_remove(buffer, text, evbuffer_get_length(buffer));

    json_error_t error;
    json_t*      input  = json_loads(text, 0, &error);
    json_t*      output = json_object();

    printf("%s\n", text);

    if (evhttp_request_get_command(request) != EVHTTP_REQ_POST) {
        goto error;
    }

    if (input == NULL) {
        SERR(server, "RPC.JSON: error on line %d: %s", error.line, error.text);

        goto error;
    }

    CD_EventDispatch(server, "RPC.JSON", input, output);

done: {
        char*            outString = json_dumps(output, JSON_INDENT(2));
        struct evbuffer* outBuffer = evbuffer_new();

        evbuffer_add_printf(outBuffer, "%s", outString);

        evhttp_send_reply(request, HTTP_OK, "OK", outBuffer);

        evbuffer_free(outBuffer);
        free(outString);
        json_delete(output);
        json_delete(input);
        CD_free(text);

        return;
    }

error: {
        evhttp_send_error(request, HTTP_INTERNAL, "Internal server error");

        CD_free(text);

        if (input) {
            json_delete(input);
        }

        if (output) {
            json_delete(output);
        }

        return;
    }
}
Esempio n. 2
0
int Server::sub(struct evhttp_request *req, Subscriber::Type sub_type){
	if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){
		evhttp_send_reply(req, 405, "Method Not Allowed", NULL);
		return 0;
	}
	bufferevent_enable(req->evcon->bufev, EV_READ);

	HttpQuery query(req);
	int seq = query.get_int("seq", 0);
	int noop = query.get_int("noop", 0);
	const char *cb = query.get_str("cb", DEFAULT_JSONP_CALLBACK);
	const char *token = query.get_str("token", "");
	std::string cname = query.get_str("cname", "");

	Channel *channel = this->get_channel_by_name(cname);
	if(!channel && this->auth == AUTH_NONE){
		channel = this->new_channel(cname);
		if(!channel){
			evhttp_send_reply(req, 429, "Too Many Channels", NULL);
			return 0;
		}
	}
	if(!channel || (this->auth == AUTH_TOKEN && channel->token != token)){
		channel->error_token_error(req, cb, token);
		return 0;
	}
	if(channel->subs.size >= ServerConfig::max_subscribers_per_channel){
		channel->error_too_many_subscribers(req, cb);
		return 0;
	}
	
	if(channel->idle < ServerConfig::channel_idles){
		channel->idle = ServerConfig::channel_idles;
	}
	
	// send buffered messages
	if(!channel->msg_list.empty() && channel->seq_next != seq){
		//channel->send_old_msgs(req, seq, cb);
		//return 0;
	}
	
	Subscriber *sub = sub_pool.alloc();
	sub->req = req;
	sub->serv = this;
	sub->type = sub_type;
	sub->idle = 0;
	sub->seq = seq;
	sub->noop_seq = noop;
	sub->callback = cb;
	
	channel->add_subscriber(sub);
	subscribers ++;
	log_debug("%s:%d sub %s, subs: %d, channels: %d",
		req->remote_host, req->remote_port,
		channel->name.c_str(), channel->subs.size,
		used_channels.size);
	sub->start();

	return 0;
}
Esempio n. 3
0
void request_handler(struct evhttp_request *req, void *arg)
{
    // resolve route
    char *decode_uri = strdup((char *)evhttp_request_uri(req));
    fprintf(stdout , "request: %s\n", decode_uri);
    int i = 0;
    for (; ;) {
        if (route_table[i].prefix == NULL && route_table[i].type == 0) {
            break;
        }
        enum evhttp_cmd_type type = evhttp_request_get_command(req);
        if (strncmp(route_table[i].prefix, decode_uri, strlen(route_table[i].prefix)) == 0
                && route_table[i].type == type) {
            route_table[i].callback(req, arg);
            goto end;
        }
        i++;
    }
    send_404_page(req);
    fprintf(stderr, "404:%s\n", decode_uri);

end:
    free(decode_uri);
    return;
}
Esempio n. 4
0
int Server::broadcast(struct evhttp_request *req){
	if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){
		evhttp_send_reply(req, 405, "Invalid Method", NULL);
		return 0;
	}
	
	HttpQuery query(req);
	const char *content = query.get_str("content", "");
	log_debug("%s:%d broadcast, content: %s",
		req->remote_host, req->remote_port, content);
	
	LinkedList<Channel *>::Iterator it = used_channels.iterator();
	while(Channel *channel = it.next()){
		if(channel->idle < ServerConfig::channel_idles){
			channel->idle = ServerConfig::channel_idles;
		}
		channel->send("broadcast", content, false);
	}

	struct evbuffer *buf = evhttp_request_get_output_buffer(req);
	evbuffer_add_printf(buf, "ok\n");
	evhttp_send_reply(req, 200, "OK", buf);

	return 0;
}
Esempio n. 5
0
static void http_request_cb(struct evhttp_request *req, void *arg)
{
    struct context *ctx = (struct context *) arg;
    const char *uri = evhttp_request_get_uri(req);
    struct evbuffer *evb = NULL;
    const char *type;

    if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
    {
        evhttp_send_error(req, HTTP_BADREQUEST, 0);
        return;
    }

    printf("GET: %s",  uri);

    if (strcmp(uri,"/") == 0)
    {
        type = "text/html";
        evb = evbuffer_new();
        evbuffer_add_printf(evb, "<html><body><h1>Hello World!</h1></body></html>");
        evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", type);
        evhttp_send_reply(req, 200, "OK", evb);
        printf(" - 200 - ok\n");
    }
    else if (strcmp(uri,"/sample") == 0)
    {
        evb = evbuffer_new();
        if (get_sample(ctx) == 0)
        {
            if (format_sample_response(ctx, evb) == 0)
            {
                evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", "application/json");
                evhttp_send_reply(req, 200, "OK", evb);
                printf(" - 200 - ok\n");
            }
            else
            {
                internal_error(req, evb);
            }
        }
        else
        {
            internal_error(req, evb);
        }
    }
    else
    {
        type = "text/plain";
        evb = evbuffer_new();
        evbuffer_add_printf(evb, "Not Found");
        evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", type);
        evhttp_send_reply(req, 404, "Not Found", evb);
        printf(" - 404 - not found\n");
    }

    if (evb)
        evbuffer_free(evb);
}
Esempio n. 6
0
int Server::pub(struct evhttp_request *req, bool encoded){
	if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){
		evhttp_send_reply(req, 405, "Invalid Method", NULL);
		return 0;
	}
	
	HttpQuery query(req);
	const char *cb = query.get_str("cb", NULL);
	std::string cname = query.get_str("cname", "");
	const char *content = query.get_str("content", "");
	
	Channel *channel = NULL;
	channel = this->get_channel_by_name(cname);
	if(!channel){
		channel = this->new_channel(cname);
		if(!channel){
			evhttp_send_reply(req, 429, "Too Many Channels", NULL);
			return 0;
		}
		int expires = ServerConfig::channel_timeout;
		log_debug("auto sign channel on pub, cname:%s, t:%s, expires:%d",
			cname.c_str(), channel->token.c_str(), expires);
		channel->idle = expires/CHANNEL_CHECK_INTERVAL;
		/*
		struct evbuffer *buf = evbuffer_new();
		log_trace("cname[%s] not connected, not pub content: %s", cname.c_str(), content);
		evbuffer_add_printf(buf, "cname[%s] not connected\n", cname.c_str());
		evhttp_send_reply(req, 404, "Not Found", buf);
		evbuffer_free(buf);
		return 0;
		*/
	}
	log_debug("%s:%d pub %s, seq: %d, subs: %d, content: %s",
		req->remote_host, req->remote_port,
		channel->name.c_str(), channel->seq_next, channel->subs.size, content);
		
	// response to publisher
	evhttp_add_header(req->output_headers, "Content-Type", "text/javascript; charset=utf-8");
	struct evbuffer *buf = evbuffer_new();
	if(cb){
		evbuffer_add_printf(buf, "%s(", cb);
	}
	evbuffer_add_printf(buf, "{\"type\":\"ok\"}");
	if(cb){
		evbuffer_add(buf, ");\n", 3);
	}else{
		evbuffer_add(buf, "\n", 1);
	}
	evhttp_send_reply(req, 200, "OK", buf);
	evbuffer_free(buf);

	// push to subscribers
	if(channel->idle < ServerConfig::channel_idles){
		channel->idle = ServerConfig::channel_idles;
	}
	channel->send("data", content, encoded);
	return 0;
}
Esempio n. 7
0
int Server::sub(struct evhttp_request *req, Subscriber::Type sub_type){
	if(evhttp_request_get_command(req) != EVHTTP_REQ_GET){
		evhttp_send_reply(req, 405, "Method Not Allowed", NULL);
		return 0;
	}

	HttpQuery query(req);
	int seq = query.get_int("seq", 0);
	int noop = query.get_int("noop", 0);
	const char *cb = query.get_str("cb", "");
	const char *token = query.get_str("token", "");
	std::string cname = query.get_str("cname", "");

	Channel *channel = this->get_channel_by_name(cname);
	if(!channel && this->auth == AUTH_NONE){
		channel = this->new_channel(cname);
		if(!channel){
			//evhttp_send_reply(req, 429, "Too many channels", NULL);
			Subscriber::send_error_reply(sub_type, req, cb, cname, "429", "Too many channels");
			return 0;
		}
	}
	if(!channel || (this->auth == AUTH_TOKEN && channel->token != token)){
		//evhttp_send_reply(req, 401, "Token error", NULL);
		log_info("%s:%d sub %s, token: %s, token error!",
			req->remote_host, req->remote_port, cname.c_str(), token);
		Subscriber::send_error_reply(sub_type, req, cb, cname, "401", "Token error");
		return 0;
	}
	if(channel->subs.size >= ServerConfig::max_subscribers_per_channel){
		//evhttp_send_reply(req, 429, "Too many subscribers", NULL);
		Subscriber::send_error_reply(sub_type, req, cb, cname, "429", "Too many subscribers");
		return 0;
	}
	
	if(channel->idle < ServerConfig::channel_idles){
		channel->idle = ServerConfig::channel_idles;
	}

	Subscriber *sub = new Subscriber();
	sub->req = req;
	sub->type = sub_type;
	sub->idle = 0;
	sub->seq_next = seq;
	sub->seq_noop = noop;
	sub->callback = cb;
	
	channel->add_subscriber(sub);
	subscribers ++;

	log_debug("%s:%d sub %s, seq: %d, subs: %d",
		req->remote_host, req->remote_port,
		channel->name.c_str(), seq, channel->subs.size);

	sub->start();
	return 0;
}
Esempio n. 8
0
void shutdown_handler(struct evhttp_request *req, void *arg)
{
    DBG();

    if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) {
        reply_error(req, HTTP_BADREQUEST, "should call with GET");
        return;
    }
    exit(0);
}
static void
post_command_cb(struct evhttp_request *req, void *arg) {
    size_t sz;
    int buffer_sz;
    struct evbuffer *buf;
    char *buffer = NULL;
    pid_t pid;

    log_write(INFO, "http-server: POST command cb\n");

    if (EVHTTP_REQ_POST != evhttp_request_get_command(req)) {
        log_write(WARN, "http-server: Not support this method.\n");
        evhttp_send_reply(req, 500, "not support this method", NULL);
        return;
    }
    log_write(INFO, "http-server: POST Request.\n");

    buf = evhttp_request_get_input_buffer(req);
    sz = evbuffer_get_length(buf);

    buffer = malloc(sz + 1);
    if (NULL == buffer) {
        log_write(ERROR, "http-server: alloc memory error.\n");
        evhttp_send_reply(req, 500, "alloc memroy error", NULL);
        return ;
    }

    /* Init temp buffer */
    memset(buffer, 0, sz + 1);
    buffer_sz = evbuffer_remove(buf, buffer, sz);
    if (sz != buffer_sz) {
        log_write(ERROR, "http-server: post content error. sz: %ld, buffer_sz:%ld\n", sz, buffer_sz);
        evhttp_send_reply(req, 501, "post content error", NULL);
        free(buffer);
        buffer = NULL;

        return ;
    }

    /* NEED parser POST body and executed it */
    int execrc = shell_cmd(buffer);
    if (0 == execrc) {
        log_write(INFO, "http-server: reply 200 OK. %d\n", execrc);
        evhttp_send_reply(req, 200, "OK", NULL);
    } else {
        log_write(ERROR, "fork error. %d\n", execrc);
        evhttp_send_reply(req, 502, "ERR", NULL);
    }

    free(buffer);
    buffer = NULL;

    return ;
}
static void parseRequest(RequestInfo& requestInfo) {
  const struct evhttp_uri* uri = evhttp_request_get_evhttp_uri(requestInfo.req);
  /*const*/ struct evhttp_connection* conn = evhttp_request_get_connection(requestInfo.req);
  
  requestInfo.method = evhttp_request_get_command(requestInfo.req);
  requestInfo.uriHost = evhttp_uri_get_host(uri);
  requestInfo.uriPath = evhttp_uri_get_path(uri);
  requestInfo.uriQuery = evhttp_uri_get_query(uri);
  requestInfo.uriScheme = evhttp_uri_get_scheme(uri);
  requestInfo.requestHeaders = evhttp_request_get_input_headers(requestInfo.req);
  requestInfo.requestBody = evhttp_request_get_input_buffer(requestInfo.req);
  evhttp_connection_get_peer(conn, &requestInfo.remoteAddress, (ev_uint16_t*) &requestInfo.remotePort);
}
Esempio n. 11
0
static void handle_user_request(struct evhttp_request *request,
                                char *action,
                                const char *canonical_username,
                                sp_session *session) {
  if (action == NULL) {
    evhttp_send_error(request, HTTP_BADREQUEST, "Bad Request");
    return;
  }

  int http_method = evhttp_request_get_command(request);

  switch (http_method) {
    case EVHTTP_REQ_GET:
      if (strncmp(action, "playlists", 9) == 0) {
        sp_playlistcontainer *pc = sp_session_publishedcontainer_for_user_create(
            session, canonical_username);

        if (sp_playlistcontainer_is_loaded(pc)) {
          get_user_playlists(pc, request, session);
        } else {
          register_playlistcontainer_callbacks(pc, request,
              &get_user_playlists,
              &playlistcontainer_loaded_callbacks,
              session);
        }
      } else if (strncmp(action, "starred", 7) == 0) {
        sp_playlist *playlist = sp_session_starred_for_user_create(session,
            canonical_username);

        if (sp_playlist_is_loaded(playlist)) {
          get_playlist(playlist, request, session);
        } else {
          register_playlist_callbacks(playlist, request, &get_playlist,
              &playlist_state_changed_callbacks,
              session);
        }
      }
      break;

    case EVHTTP_REQ_PUT:
    case EVHTTP_REQ_POST:
      if (strncmp(action, "inbox", 5) == 0) {
        put_user_inbox(canonical_username, request, session);
      }
      break;

    default:
      evhttp_send_error(request, HTTP_BADREQUEST, "Bad Request");
      break;
  }
}
void HTTPHandler::info_handle(struct evhttp_request *req, void *arg) {
  if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
    return;

  LOG(INFO) << "Request for server infomation.";

  // TODO(binfei): need memory pool
  struct evbuffer *databuf = evbuffer_new();
  evbuffer_add_printf(databuf, "hello world");
  evhttp_send_reply_start(req, 200, "OK");
  evhttp_send_reply_chunk(req, databuf);
  evhttp_send_reply_end(req);
  evbuffer_free(databuf);
}
Esempio n. 13
0
void get_master_pgn(struct evhttp_request *req, void *context) {
    if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) {
        evhttp_send_error(req, HTTP_BADMETHOD, "Method Not Allowed");
        return;
    }

    const struct evhttp_uri *uri = evhttp_request_get_evhttp_uri(req);
    if (!uri) {
        puts("evhttp_request_get_evhttp_uri failed");
        return;
    }

    const char *path = evhttp_uri_get_path(uri);
    if (!path) {
        puts("evhttp_uri_get_path failed");
        return;
    }

    char game_id[9] = {};
    int end;
    if (1 != sscanf(path, "/master/pgn/%8s%n", game_id, &end) ||
            strlen(game_id) != 8 ||
            strlen(path) != end) {
        evhttp_send_error(req, HTTP_NOTFOUND, "Not Found");
        return;
    }

    size_t pgn_size;
    char *pgn = kcdbget(master_pgn_db, game_id, 8, &pgn_size);
    if (!pgn) {
        evhttp_send_error(req, HTTP_NOTFOUND, "Master PGN Not Found");
        return;
    }

    struct evbuffer *res = evbuffer_new();
    if (!res) {
        puts("could not allocate response buffer");
        abort();
    }

    struct evkeyvalq *headers = evhttp_request_get_output_headers(req);
    evhttp_add_header(headers, "Content-Type", "application/vnd.chess-pgn; charset=utf-8");

    evbuffer_add(res, pgn, pgn_size);
    kcfree(pgn);

    evhttp_send_reply(req, HTTP_OK, "OK", res);
    evbuffer_free(res);
}
int HttpServerMsgHandler::processMessage(void *arg) {
	struct evhttp_request *req = (struct evhttp_request *)arg;

	const char *cmdtype;
	struct evkeyvalq *headers;
	struct evkeyval *header;

	switch (evhttp_request_get_command(req)) {
	case EVHTTP_REQ_GET: cmdtype = "GET"; break;
	case EVHTTP_REQ_POST: cmdtype = "POST"; break;
	case EVHTTP_REQ_HEAD: cmdtype = "HEAD"; break;
	case EVHTTP_REQ_PUT: cmdtype = "PUT"; break;
	case EVHTTP_REQ_DELETE: cmdtype = "DELETE"; break;
	case EVHTTP_REQ_OPTIONS: cmdtype = "OPTIONS"; break;
	case EVHTTP_REQ_TRACE: cmdtype = "TRACE"; break;
	case EVHTTP_REQ_CONNECT: cmdtype = "CONNECT"; break;
	case EVHTTP_REQ_PATCH: cmdtype = "PATCH"; break;
	default: cmdtype = "unknown"; break;
	}

	printf("Received a %s request for %s\nHeaders:\n",
		cmdtype, evhttp_request_get_uri(req));

	headers = evhttp_request_get_input_headers(req);
	for (header = headers->tqh_first; header;
		header = header->next.tqe_next) {
			printf("  %s: %s\n", header->key, header->value);
	}

	ConnectionManager *conn = ConnectionManager::getInstance();
	struct evbuffer *return_buffer=evbuffer_new();

	long long total_req = conn->getTotalRequests();
	long long total_res = conn->getTotalResponses();
	unsigned int conns = conn->getConnections();

	long long timeouts = conn->getTimeoutRequests();
	long long err_res = conn->getErrorResponses();
	long long conn_except = conn->getConnExceptions();
	long long ok_res = conn->getOkResponses();

	evbuffer_add_printf(return_buffer,"    total request: %lld<br>	   total response: %lld<br>	   connnections: %u<br><br><hr><br>	ok: %lld	\
		<br>	timeout: %lld<br>	http error: %lld<br>    connExcept: %u<br>"
		, total_req, total_res, conns, ok_res, timeouts, err_res, conn_except);
	evhttp_send_reply(req, HTTP_OK, "OK", return_buffer);
	evbuffer_free(return_buffer);

	return 0;
}
Esempio n. 15
0
	HttpQuery(struct evhttp_request *req){
		_has_post = false;
		if(evhttp_request_get_command(req) == EVHTTP_REQ_POST){
			evbuffer *body_evb = evhttp_request_get_input_buffer(req);
			size_t len = evbuffer_get_length(body_evb);
			if(len > 0){
				_has_post = true;
				char *data = (char *)malloc(len + 1);
				evbuffer_copyout(body_evb, data, len);
				data[len] = '\0';
				evhttp_parse_query_str(data, &_post);
				free(data);
			}
		}
		evhttp_parse_query(evhttp_request_get_uri(req), &_get);
	}
Esempio n. 16
0
void write_chunk(uint64_t chunkid, struct evhttp_request *req)
{
    DBG();
    struct evbuffer *input;
    struct evbuffer *evb = evbuffer_new();

    if (evhttp_request_get_command(req) != EVHTTP_REQ_POST) {
        reply_error(req, HTTP_BADREQUEST, "should call write with POST");
        return;
    }
    uint64_t start = 0, end;
    const char *range = evhttp_find_header(req->input_headers, "Range");

    logging(LOG_DEUBG, "write Range Header: %s", range);
    if (range) {
        sscanf(range, "bytes=%" SCNu64 "-%" SCNu64, &start, &end);
    }

    input = req->input_buffer;
    hdd_chunk *chunk = hdd_create_chunk(chunkid, 0);    //TODO

    int fd = open(chunk->path, O_WRONLY | O_CREAT, 0755);
    logging(LOG_DEUBG, "write seek to : %" PRIu64 "", start);
    logging(LOG_DEUBG, "evbuffer_get_length(input) = %d",
            evbuffer_get_length(input));
    lseek(fd, start, SEEK_SET);

    if (-1 == fd) {
        reply_error(req, HTTP_INTERNAL, "could not open file : %s",
                    chunk->path);
        return;
    }

    int rst = 0;
    while (evbuffer_get_length(input) && (rst = evbuffer_write(input, fd)) > 0) {
        ;
    }

    /*evbuffer_write(input, fd); */
    close(fd);

    evbuffer_add(evb, "success", strlen("success"));
    evhttp_send_reply(req, HTTP_OK, "OK", evb);
    evbuffer_free(evb);
}
Esempio n. 17
0
/* Callback used for the /dump URI, and for every non-GET request:
 * dumps all information to stdout and gives back a trivial 200 ok */
static void
dump_request_cb(struct evhttp_request *req, void *arg)
{
	const char *cmdtype;
	struct evkeyvalq *headers;
	struct evkeyval *header;
	struct evbuffer *buf;

	switch (evhttp_request_get_command(req)) {
	case EVHTTP_REQ_GET: cmdtype = "GET"; break;
	case EVHTTP_REQ_POST: cmdtype = "POST"; break;
	case EVHTTP_REQ_HEAD: cmdtype = "HEAD"; break;
	case EVHTTP_REQ_PUT: cmdtype = "PUT"; break;
	case EVHTTP_REQ_DELETE: cmdtype = "DELETE"; break;
	case EVHTTP_REQ_OPTIONS: cmdtype = "OPTIONS"; break;
	case EVHTTP_REQ_TRACE: cmdtype = "TRACE"; break;
	case EVHTTP_REQ_CONNECT: cmdtype = "CONNECT"; break;
	case EVHTTP_REQ_PATCH: cmdtype = "PATCH"; break;
	default: cmdtype = "unknown"; break;
	}

	printf("Received a %s request for %s\nHeaders:\n",
	    cmdtype, evhttp_request_get_uri(req));

	headers = evhttp_request_get_input_headers(req);
	for (header = headers->tqh_first; header;
	    header = header->next.tqe_next) {
		printf("  %s: %s\n", header->key, header->value);
	}

	buf = evhttp_request_get_input_buffer(req);
	puts("Input data: <<<");
	while (evbuffer_get_length(buf)) {
		int n;
		char cbuf[128];
		n = evbuffer_remove(buf, cbuf, sizeof(cbuf));
		if (n > 0)
			(void) fwrite(cbuf, 1, n, stdout);
	}
	puts(">>>");

	evhttp_send_reply(req, 200, "OK", NULL);
}
Esempio n. 18
0
HTTPRequest::RequestMethod HTTPRequest::GetRequestMethod()
{
    switch (evhttp_request_get_command(req)) {
    case EVHTTP_REQ_GET:
        return GET;
        break;
    case EVHTTP_REQ_POST:
        return POST;
        break;
    case EVHTTP_REQ_HEAD:
        return HEAD;
        break;
    case EVHTTP_REQ_PUT:
        return PUT;
        break;
    default:
        return UNKNOWN;
        break;
    }
}
Esempio n. 19
0
/*
 * Get request command (i.e method)
 *
 * @return [String] http method for known command
 * @return [nil] if method is not supported
 * @example
 *   GET
 */
static VALUE t_get_command(VALUE self) {
    Libevent_HttpRequest *http_request;
    VALUE command;

    Data_Get_Struct(self, Libevent_HttpRequest, http_request);

    switch ( evhttp_request_get_command(http_request->ev_request) ) {
    case EVHTTP_REQ_GET     :
        command = rb_str_new2("GET");
        break;
    case EVHTTP_REQ_POST    :
        command = rb_str_new2("POST");
        break;
    case EVHTTP_REQ_HEAD    :
        command = rb_str_new2("HEAD");
        break;
    case EVHTTP_REQ_PUT     :
        command = rb_str_new2("PUT");
        break;
    case EVHTTP_REQ_DELETE  :
        command = rb_str_new2("DELETE");
        break;
    case EVHTTP_REQ_OPTIONS :
        command = rb_str_new2("OPTIONS");
        break;
    case EVHTTP_REQ_TRACE   :
        command = rb_str_new2("TRACE");
        break;
    case EVHTTP_REQ_CONNECT :
        command = rb_str_new2("CONNECT");
        break;
    case EVHTTP_REQ_PATCH   :
        command = rb_str_new2("PATCH");
        break;
    default:
        command = Qnil;
        break;
    }

    return command;
}
Esempio n. 20
0
const char *xBlog::DebugHttpGetCommand(struct evhttp_request *req)
{
    const char *cmdtype;

    switch (evhttp_request_get_command(req))
    {
    case EVHTTP_REQ_GET:
        cmdtype = "GET";
        break;
    case EVHTTP_REQ_POST:
        cmdtype = "POST";
        break;
    case EVHTTP_REQ_HEAD:
        cmdtype = "HEAD";
        break;
    case EVHTTP_REQ_PUT:
        cmdtype = "PUT";
        break;
    case EVHTTP_REQ_DELETE:
        cmdtype = "DELETE";
        break;
    case EVHTTP_REQ_OPTIONS:
        cmdtype = "OPTIONS";
        break;
    case EVHTTP_REQ_TRACE:
        cmdtype = "TRACE";
        break;
    case EVHTTP_REQ_CONNECT:
        cmdtype = "CONNECT";
        break;
    case EVHTTP_REQ_PATCH:
        cmdtype = "PATCH";
        break;
    default:
        cmdtype = "unknown";
        break;
    }

    log_debug("Received a %s request for %s \n", cmdtype, evhttp_request_get_uri(req));
    return cmdtype;
}
Esempio n. 21
0
void httpserver_handler(struct evhttp_request *req, void *arg)  
{  
    int fd=open("./test.html",O_RDONLY);
    const char *cmdtype;   
    struct evbuffer *buf = evbuffer_new();  
    if (buf == NULL)   
    {  
        printf("evbuffer_new error !\n");  
        return;  
    }  
      
    switch (evhttp_request_get_command(req))  
    {    
        case EVHTTP_REQ_GET:    cmdtype = "GET";    break;    
        case EVHTTP_REQ_POST:   cmdtype = "POST";   break;    
        case EVHTTP_REQ_HEAD:   cmdtype = "HEAD";   break;    
        case EVHTTP_REQ_PUT:    cmdtype = "PUT";    break;    
        case EVHTTP_REQ_DELETE: cmdtype = "DELETE"; break;    
        case EVHTTP_REQ_OPTIONS:cmdtype = "OPTIONS";break;    
        case EVHTTP_REQ_TRACE:  cmdtype = "TRACE";  break;    
        case EVHTTP_REQ_CONNECT:cmdtype = "CONNECT";break;    
        case EVHTTP_REQ_PATCH:  cmdtype = "PATCH";  break;    
        default: cmdtype = "unknown"; break;    
    }  
  
    printf("%s url=%s \n", cmdtype, evhttp_request_get_uri(req));  
  
    //evbuffer_add_printf(buf,"<html>\n"  
    //        "<head>\n"  
    //        "  <title>Libevnet Test</title>\n"            
    //        "</head>\n"  
    //        "<body>\n"  
    //        "  <h1>Hello world ,This is a Libenvet Test !</h1>\n"            
    //        "</body>\n"  
    //        "</html>\n");
    evbuffer_read(buf,fd,75);
    evhttp_send_reply(req, 200, "OK", buf);    
}   
Esempio n. 22
0
File: request.cpp Progetto: respu/w
    Request make_request_from_evhttp_request(evhttp_request* req) {
      Request r;

      switch (evhttp_request_get_command(req)) {
        case EVHTTP_REQ_GET:     r.method = "GET";     break;
        case EVHTTP_REQ_POST:    r.method = "POST";    break;
        case EVHTTP_REQ_HEAD:    r.method = "HEAD";    break;
        case EVHTTP_REQ_PUT:     r.method = "PUT";     break;
        case EVHTTP_REQ_DELETE:  r.method = "DELETE";  break;
        case EVHTTP_REQ_OPTIONS: r.method = "OPTIONS"; break;
        case EVHTTP_REQ_TRACE:   r.method = "TRACE";   break;
        case EVHTTP_REQ_CONNECT: r.method = "CONNECT"; break;
        case EVHTTP_REQ_PATCH:   r.method = "PATCH";   break;
      }

      evkeyvalq* headers = evhttp_request_get_input_headers(req);
      for (evkeyval* header = headers->tqh_first; header; header = header->next.tqe_next) {
        r.headers[header->key] = header->value;
      }

      evbuffer* body = evhttp_request_get_input_buffer(req);
      if (body) {
        std::stringstream body_buffer;
        while (evbuffer_get_length(body)) {
          char tmp[128];
          int n = evbuffer_remove(body, tmp, sizeof(tmp));
          if (n > 0)
            body_buffer.write(tmp, n);
        }
        r.body = body_buffer.str();
      }

      char* decoded_uri_str = evhttp_decode_uri(evhttp_request_get_uri(req));
      r.uri = URI(decoded_uri_str);
      ::free(decoded_uri_str);
      return r;
    }
Esempio n. 23
0
// Request dispatcher
static void handle_request(struct evhttp_request *request,
                            void *userdata) {
  evhttp_connection_set_timeout(request->evcon, 1);
  evhttp_add_header(evhttp_request_get_output_headers(request),
                    "Server", "[email protected]/spotify-api-server");

  // Check request method
  int http_method = evhttp_request_get_command(request);

  switch (http_method) {
    case EVHTTP_REQ_GET:
    case EVHTTP_REQ_PUT:
    case EVHTTP_REQ_POST:
      break;

    default:
      evhttp_send_error(request, HTTP_NOTIMPL, "Not Implemented");
      return;
  }

  struct state *state = userdata;
  sp_session *session = state->session;
  char *uri = evhttp_decode_uri(evhttp_request_get_uri(request));

  char *entity = strtok(uri, "/");

  if (entity == NULL) {
    evhttp_send_error(request, HTTP_BADREQUEST, "Bad Request");
    free(uri);
    return;
  }

  // Handle requests to /user/<user_name>/inbox
  if (strncmp(entity, "user", 4) == 0) {
    char *username = strtok(NULL, "/");

    if (username == NULL) {
      evhttp_send_error(request, HTTP_BADREQUEST, "Bad Request");
      free(uri);
      return;
    }

    char *action = strtok(NULL, "/");
    handle_user_request(request, action, username, session);
    free(uri);
    return;
  }

  // Handle requests to /playlist/<playlist_uri>/<action>
  if (strncmp(entity, "playlist", 8) != 0) {
    evhttp_send_error(request, HTTP_BADREQUEST, "Bad Request");
    free(uri);
    return;
  }

  char *playlist_uri = strtok(NULL, "/");

  if (playlist_uri == NULL) {
    switch (http_method) {
      case EVHTTP_REQ_PUT:
      case EVHTTP_REQ_POST:
        put_playlist(NULL, request, session);
        break;

      default:
        send_error(request, HTTP_BADREQUEST, "Bad Request");
        break;
    }

    free(uri);
    return;
  }

  sp_link *playlist_link = sp_link_create_from_string(playlist_uri);

  if (playlist_link == NULL) {
    send_error(request, HTTP_NOTFOUND, "Playlist link not found");
    free(uri);
    return;
  }

  if (sp_link_type(playlist_link) != SP_LINKTYPE_PLAYLIST) {
    sp_link_release(playlist_link);
    send_error(request, HTTP_BADREQUEST, "Not a playlist link");
    free(uri);
    return;
  }

  sp_playlist *playlist = sp_playlist_create(session, playlist_link);
  sp_link_release(playlist_link);

  if (playlist == NULL) {
    send_error(request, HTTP_NOTFOUND, "Playlist not found");
    free(uri);
    return;
  }

  sp_playlist_add_ref(playlist);

  // Dispatch request
  char *action = strtok(NULL, "/");

  // Default request handler
  handle_playlist_fn request_callback = &not_implemented;
  void *callback_userdata = session;

  switch (http_method) {
  case EVHTTP_REQ_GET:
    {
      if (action == NULL) {
        // Send entire playlist
        request_callback = &get_playlist;
      } else if (strncmp(action, "collaborative", 13) == 0) {
        request_callback = &get_playlist_collaborative;
      } else if (strncmp(action, "subscribers", 11) == 0) {
        request_callback = &get_playlist_subscribers;
      }
    }
    break;

  case EVHTTP_REQ_PUT:
  case EVHTTP_REQ_POST:
    {
      if (strncmp(action, "add", 3) == 0) {
        request_callback = &put_playlist_add_tracks;
      } else if (strncmp(action, "remove", 6) == 0) {
        request_callback = &put_playlist_remove_tracks;
      } else if (strncmp(action, "patch", 5) == 0) {
        callback_userdata = state;
        request_callback = &put_playlist_patch;
      }
    }
    break;
  }

  if (sp_playlist_is_loaded(playlist)) {
    request_callback(playlist, request, callback_userdata);
  } else {
    // Wait for playlist to load
    register_playlist_callbacks(playlist, request, request_callback,
                                &playlist_state_changed_callbacks,
                                callback_userdata);
  }

  free(uri);
}
Esempio n. 24
0
static void http_document_request_cb(struct evhttp_request *req, void *arg)
{
    struct evbuffer *evb = NULL;
    struct http *http = (struct http *) arg;
    const char *docroot = http->docroot;
    const char *uri = evhttp_request_get_uri(req);
    struct evhttp_uri *decoded = NULL;
    const char *path;
    char *decoded_path;
    char *whole_path = NULL;
    size_t len;
    int fd = -1;
    struct stat st;

    if (evhttp_request_get_command(req) != EVHTTP_REQ_GET)
    {
        evhttp_send_error(req, HTTP_BADREQUEST, 0);
        return;
    }

    printf("GET: %s\n",  uri);

    /* Decode the URI */
    decoded = evhttp_uri_parse(uri);
    if (!decoded)
    {
        evhttp_send_error(req, HTTP_BADREQUEST, 0);
        return;
    }

    /* Let's see what path the user asked for. */
    path = evhttp_uri_get_path(decoded);
    if (!path) path = "/";

    /* We need to decode it, to see what path the user really wanted. */
    decoded_path = evhttp_uridecode(path, 0, NULL);
    if (decoded_path == NULL)
        goto err;

    /* Don't allow any ".."s in the path, to avoid exposing stuff outside
     * of the docroot.  This test is both overzealous and underzealous:
     * it forbids aceptable paths like "/this/one..here", but it doesn't
     * do anything to prevent symlink following." */
    if (strstr(decoded_path, ".."))
        goto err;

    len = strlen(decoded_path) + strlen(docroot) + 2;
    if (!(whole_path = malloc(len)))
    {
        goto err;
    }

    snprintf(whole_path, len, "%s/%s", docroot, decoded_path);

    if (stat(whole_path, &st) < 0)
    {
        goto err;
    }

    /* This holds the content we're sending. */
    evb = evbuffer_new();

    if (S_ISDIR(st.st_mode))
    {
        /* TODO: send index.html if the request is for a directory */
        goto err;
    }
    else
    {
        /* Otherwise it's a file; add it to the buffer to get
         * sent via sendfile */
        const char *type = guess_content_type(decoded_path);
        if ((fd = open(whole_path, O_RDONLY)) < 0)
        {
            goto err;
        }

        if (fstat(fd, &st) < 0)
        {
            /* Make sure the length still matches, now that we
             * opened the file :/ */
            goto err;
        }

        evhttp_add_header(evhttp_request_get_output_headers(req), "Content-Type", type);

        /* TODO: does this read the whole thing into memory??  well, we are only going to be
         * serving small files out of the static content directory, so its probably OK. */
        evbuffer_add_file(evb, fd, 0, st.st_size);
    }

    evhttp_send_reply(req, 200, "OK", evb);
    goto done;

err:
    evhttp_send_error(req, 404, "Document was not found");
    if (fd >= 0)
        close(fd);

done:
    if (decoded)
        evhttp_uri_free(decoded);

    if (decoded_path)
        free(decoded_path);

    if (whole_path)
        free(whole_path);

    if (evb)
        evbuffer_free(evb);
}
Esempio n. 25
0
/* This callback gets invoked when we get any http request that doesn't match
 * any other callback.  Like any evhttp server callback, it has a simple job:
 * it must eventually call evhttp_send_error() or evhttp_send_reply().
 */
static void
send_document_cb(struct evhttp_request *req, void *arg)
{
	struct evbuffer *evb = NULL;
	const char *docroot = arg;
	const char *uri = evhttp_request_get_uri(req);
	struct evhttp_uri *decoded = NULL;
	const char *path;
	char *decoded_path;
	char *whole_path = NULL;
	size_t len;
	int fd = -1;
	struct stat st;

	if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) {
		dump_request_cb(req, arg);
		return;
	}

	printf("Got a GET request for <%s>\n",  uri);

	/* Decode the URI */
	decoded = evhttp_uri_parse(uri);
	if (!decoded) {
		printf("It's not a good URI. Sending BADREQUEST\n");
		evhttp_send_error(req, HTTP_BADREQUEST, 0);
		return;
	}

	/* Let's see what path the user asked for. */
	path = evhttp_uri_get_path(decoded);
	if (!path) path = "/";

	/* We need to decode it, to see what path the user really wanted. */
	decoded_path = evhttp_uridecode(path, 0, NULL);
	if (decoded_path == NULL)
		goto err;
	/* Don't allow any ".."s in the path, to avoid exposing stuff outside
	 * of the docroot.  This test is both overzealous and underzealous:
	 * it forbids aceptable paths like "/this/one..here", but it doesn't
	 * do anything to prevent symlink following." */
	if (strstr(decoded_path, ".."))
		goto err;

	len = strlen(decoded_path)+strlen(docroot)+2;
	if (!(whole_path = malloc(len))) {
		perror("malloc");
		goto err;
	}
	evutil_snprintf(whole_path, len, "%s/%s", docroot, decoded_path);

	if (stat(whole_path, &st)<0) {
		goto err;
	}

	/* This holds the content we're sending. */
	evb = evbuffer_new();

	if (S_ISDIR(st.st_mode)) {
		/* If it's a directory, read the comments and make a little
		 * index page */
#ifdef WIN32
		HANDLE d;
		WIN32_FIND_DATAA ent;
		char *pattern;
		size_t dirlen;
#else
		DIR *d;
		struct dirent *ent;
#endif
		const char *trailing_slash = "";

		if (!strlen(path) || path[strlen(path)-1] != '/')
			trailing_slash = "/";

#ifdef WIN32
		dirlen = strlen(whole_path);
		pattern = malloc(dirlen+3);
		memcpy(pattern, whole_path, dirlen);
		pattern[dirlen] = '\\';
		pattern[dirlen+1] = '*';
		pattern[dirlen+2] = '\0';
		d = FindFirstFileA(pattern, &ent);
		free(pattern);
		if (d == INVALID_HANDLE_VALUE)
			goto err;
#else
		if (!(d = opendir(whole_path)))
			goto err;
#endif

		evbuffer_add_printf(evb, "<html>\n <head>\n"
		    "  <title>%s</title>\n"
		    "  <base href='%s%s%s'>\n"
		    " </head>\n"
		    " <body>\n"
		    "  <h1>%s</h1>\n"
		    "  <ul>\n",
		    decoded_path, /* XXX html-escape this. */
		    uri_root, path, /* XXX html-escape this? */
		    trailing_slash,
		    decoded_path /* XXX html-escape this */);
#ifdef WIN32
		do {
			const char *name = ent.cFileName;
#else
		while ((ent = readdir(d))) {
			const char *name = ent->d_name;
#endif
			evbuffer_add_printf(evb,
			    "    <li><a href=\"%s\">%s</a>\n",
			    name, name);/* XXX escape this */
#ifdef WIN32
		} while (FindNextFileA(d, &ent));
#else
		}
#endif
		evbuffer_add_printf(evb, "</ul></body></html>\n");
#ifdef WIN32
		FindClose(d);
#else
		closedir(d);
#endif
		evhttp_add_header(evhttp_request_get_output_headers(req),
		    "Content-Type", "text/html");
	} else {
Esempio n. 26
0
void get_master(struct evhttp_request *req, void *context) {
    if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) {
        evhttp_send_error(req, HTTP_BADMETHOD, "Method Not Allowed");
        return;
    }

    const char *uri = evhttp_request_get_uri(req);
    if (!uri) {
        puts("evhttp_request_get_uri failed");
        return;
    }

    struct evkeyvalq query;
    const char *fen = NULL;
    const char *jsonp = NULL;
    int moves = 12;
    int topGames = 4;
    if (0 == evhttp_parse_query(uri, &query)) {
        fen = evhttp_find_header(&query, "fen");
        jsonp = evhttp_find_header(&query, "callback");

        if (evhttp_find_header(&query, "moves")) {
            moves = atoi(evhttp_find_header(&query, "moves"));
        }

        if (evhttp_find_header(&query, "topGames")) {
            topGames = atoi(evhttp_find_header(&query, "topGames"));
        }
    }
    if (!fen || !strlen(fen)) {
        evhttp_send_error(req, HTTP_BADREQUEST, "Missing FEN");
        return;
    }

    // Look up positon.
    board_t pos;
    if (!board_set_fen(&pos, fen)) {
        evhttp_send_error(req, HTTP_BADREQUEST, "Invalid FEN");
    }

    if (verbose) printf("master: %.255s\n", fen);

    struct evbuffer *res = evbuffer_new();
    if (!res) {
        puts("could not allocate response buffer");
        abort();
    }

    // CORS.
    struct evkeyvalq *headers = evhttp_request_get_output_headers(req);
    if (cors) evhttp_add_header(headers, "Access-Control-Allow-Origin", "*");

    // Set Content-Type.
    if (jsonp && strlen(jsonp)) {
        evhttp_add_header(headers, "Content-Type", "application/javascript");
        evbuffer_add_printf(res, "%s(", jsonp);
    } else {
        evhttp_add_header(headers, "Content-Type", "application/json");
    }

    uint64_t zobrist_hash = board_zobrist_hash(&pos, POLYGLOT);

    struct master_record *record = master_record_new();
    size_t record_size;
    char *encoded_record = kcdbget(master_db, (const char *) &zobrist_hash, 8, &record_size);
    if (encoded_record) {
        decode_master_record((const uint8_t *) encoded_record, record);
    }

    unsigned long average_rating_sum = master_record_average_rating_sum(record);
    unsigned long total_white = master_record_white(record);
    unsigned long total_draws = master_record_draws(record);
    unsigned long total_black = master_record_black(record);
    unsigned long total = total_white + total_draws + total_black;

    evbuffer_add_printf(res, "{\n");

    // Add totals.
    evbuffer_add_printf(res, "  \"white\": %lu,\n", total_white);
    evbuffer_add_printf(res, "  \"draws\": %lu,\n", total_draws);
    evbuffer_add_printf(res, "  \"black\": %lu,\n", total_black);
    if (total) evbuffer_add_printf(res, "  \"averageRating\": %lu,\n", average_rating_sum / total);
    else evbuffer_add_printf(res, "  \"averageRating\": null,\n");

    // Add move list.
    evbuffer_add_printf(res, "  \"moves\": [\n");
    for (size_t i = 0; i < record->num_moves && i < moves; i++) {
        unsigned long move_total = record->moves[i].white + record->moves[i].draws + record->moves[i].black;

        char uci[LEN_UCI], san[LEN_SAN];
        move_uci(record->moves[i].move, uci);
        board_san(&pos, record->moves[i].move, san);

        evbuffer_add_printf(res, "    {\n");
        evbuffer_add_printf(res, "      \"uci\": \"%s\",\n", uci);
        evbuffer_add_printf(res, "      \"san\": \"%s\",\n", san);
        evbuffer_add_printf(res, "      \"white\": %lu,\n", record->moves[i].white);
        evbuffer_add_printf(res, "      \"draws\": %lu,\n", record->moves[i].draws);
        evbuffer_add_printf(res, "      \"black\": %lu,\n", record->moves[i].black);
        if (move_total) {
            evbuffer_add_printf(res, "      \"averageRating\": %lu\n", record->moves[i].average_rating_sum / move_total);
        } else {
            evbuffer_add_printf(res, "      \"averageRating\": null\n");
        }
        evbuffer_add_printf(res, "    }%s\n", (i < record->num_moves - 1 && i < moves - 1) ? "," : "");
    }

    evbuffer_add_printf(res, "  ],\n");

    // Add top games.
    evbuffer_add_printf(res, "  \"topGames\": [\n");
    for (size_t i = 0; i < record->num_refs && i < topGames; i++) {
        char game_id[9] = {};
        strncpy(game_id, record->refs[i].game_id, 8);

        size_t pgn_size;
        char *pgn = kcdbget(master_pgn_db, game_id, 8, &pgn_size);
        if (!pgn) continue;

        char *save_ptr;
        struct pgn_game_info *game_info = pgn_game_info_read(pgn, &save_ptr);
        if (!game_info->white || !game_info->black) continue;

        evbuffer_add_printf(res, "    {\n");
        // TODO: winner, white.name, white.rating, black.name, black.rating, -avg rating
        evbuffer_add_printf(res, "      \"id\": \"%s\",\n", game_id);
        evbuffer_add_printf(res, "      \"winner\": \"%s\",\n", game_info->result ? (game_info->result > 0 ? "white" : "black") : "draw");
        evbuffer_add_printf(res, "      \"white\": {\n");
        evbuffer_add_printf(res, "        \"name\": \"%s\",\n", game_info->white); // XXX TODO !
        evbuffer_add_printf(res, "        \"rating\": %d\n", game_info->white_elo);
        evbuffer_add_printf(res, "      },\n");
        evbuffer_add_printf(res, "      \"black\": {\n");
        evbuffer_add_printf(res, "        \"name\": \"%s\",\n", game_info->black); // XXX TODO !
        evbuffer_add_printf(res, "        \"rating\": %d\n", game_info->black_elo);
        evbuffer_add_printf(res, "      },\n");
        evbuffer_add_printf(res, "      \"year\": %d\n", game_info->year);
        evbuffer_add_printf(res, "    }%s\n", (i < record->num_refs - 1 && i < topGames - 1) ? "," : "");
    }
    evbuffer_add_printf(res, "  ]\n");

    evbuffer_add_printf(res, "}%s\n", (jsonp && strlen(jsonp)) ? ")" : "");

    evhttp_send_reply(req, HTTP_OK, "OK", res);
    evbuffer_free(res);
}
Esempio n. 27
0
File: HTTPd.c Progetto: Youx/craftd
static
void
cd_StaticRequest (struct evhttp_request* request, CDServer* server)
{
    int         error   = HTTP_OK;
    const char* message = "OK";

    const char*        uri     = evhttp_request_get_uri(request);
    struct evhttp_uri* decoded = evhttp_uri_parse(uri);

    if (evhttp_request_get_command(request) != EVHTTP_REQ_GET) {
        error   = HTTP_BADMETHOD;
        message = "Invalid request method";

        goto end;
    }

    if (!decoded || strstr(evhttp_uri_get_path(decoded), "..")) {
        error   = HTTP_BADREQUEST;
        message = "Bad request";

        goto end;
    }

    DO {
        CDString* path = CD_CreateStringFromFormat("%s/%s", server->config->cache.httpd.root,
        evhttp_uri_get_path(decoded) ? evhttp_uri_get_path(decoded) : "index.html");

        if (CD_IsDirectory(CD_StringContent(path))) {
            CD_AppendCString(path, "/index.html");
        }

        if (!CD_IsReadable(CD_StringContent(path))) {
            error   = HTTP_NOTFOUND;
            message = "File not found";

            CD_DestroyString(path);

            goto end;
        }

        struct evbuffer* buffer = evbuffer_new();
        int              fd     = open(CD_StringContent(path), O_RDONLY);

        evhttp_add_header(evhttp_request_get_output_headers(request),
        "Content-Type", cd_GuessContentType(CD_StringContent(path)));

        evbuffer_add_file(buffer, fd, 0, CD_FileSize(CD_StringContent(path)));

        evhttp_send_reply(request, HTTP_OK, "OK", buffer);

        evbuffer_free(buffer);
        CD_DestroyString(path);
    }

end: {
        if (decoded) {
            evhttp_uri_free(decoded);
        }

        if (error != HTTP_OK) {
            evhttp_send_error(request, error, message);
        }
    }
}
 static int64_t HHVM_METHOD(EventHttpRequest, getCommand) {
     EventHttpRequestResourceData *event_http_request_resource_data = FETCH_RESOURCE(this_, EventHttpRequestResourceData, s_event_http_request);
     return evhttp_request_get_command((evhttp_request_t *) event_http_request_resource_data->getInternalResourceData());
 }
Esempio n. 29
0
void servlet(struct evhttp_request *req, struct evbuffer *evb, const char *get_query) {
    /*dbi_conn conn;
    dbi_result result;           
    unsigned int idnumber;
    char *fullname;
    
    dbi_initialize(NULL);
    conn = dbi_conn_new("mysql");    
    dbi_conn_set_option(conn, "host", "localhost");
    dbi_conn_set_option(conn, "username", "root");
    dbi_conn_set_option(conn, "password", "root");
    dbi_conn_set_option(conn, "dbname", "test");
    dbi_conn_set_option(conn, "encoding", "UTF-8");
    if (dbi_conn_connect(conn) < 0) {
      printf("Could not connect");
    } else {
        result = dbi_conn_queryf(conn, "SELECT id, name FROM test");
        
        if (result) {
            printf("dbi_result_get_numrows: %u", dbi_result_get_numrows(result));
            
            while (dbi_result_next_row(result)) {
                idnumber = dbi_result_get_uint(result, "id");
                fullname = dbi_result_get_string(result, "name");
                printf("%i. %s", idnumber, fullname);
            }
        
            dbi_result_free(result);
        }
        
        dbi_conn_close(conn);      
    }*/
    

    
    time_t now;
    time(&now);
    const char *value;
    struct evkeyvalq params;
    char *data;
    size_t len;


    if (evhttp_request_get_command(req) == EVHTTP_REQ_GET) {
        evhttp_parse_query_str(get_query, &params);
        value = evhttp_find_header(&params, "first_name");
    } else {
        len = evbuffer_get_length(evhttp_request_get_input_buffer(req));
        struct evbuffer *in_evb = evhttp_request_get_input_buffer(req);
        data = malloc(len + 1);
        evbuffer_copyout(in_evb, data, len);
        data[len] = '\0';
        evhttp_parse_query_str(data, &params);
        value = evhttp_find_header(&params, "first_name");
    }

    
    evbuffer_add_printf(evb, "<html>\n <head>\n"
	    "  <title>C servlet</title>\n"
	    " </head>\n"
	    " <body>\n"
	    "  <h1>C servlet</h1>\n"
	    " <p>Current time is: %s (GMT)</p>" 
	    " <p>First name is: %s</p>\n<hr>\n"
	    "<form action=\"/servlet\" method=\"POST\">\n"
	    "First name <input type=\"text\" name=\"first_name\">"
	    "<input type=\"submit\" value=\"send via post\">"
	    "</form>\n"
	    "<p>COOKIE: %s</p>"
	    "<p><a href=\"/servlet?first_name=John\">GET with parameters</a></p>"
	    "</body><html>", 
	    ctime(&now),
        value,
	    http_get_cookie(req, "CSESSID"));
    evhttp_add_header(evhttp_request_get_output_headers(req),
	    "Content-Type", "text/html");
	evhttp_add_header(evhttp_request_get_output_headers(req),
	    "Set-Cookie", "CSESSID=435J43L523J4TTYYY; Path=/; Domain=intranet2.local");
	evhttp_add_header(evhttp_request_get_output_headers(req),
	    "Set-Cookie", "[email protected]; Path=/; Domain=intranet2.local");
	evhttp_add_header(evhttp_request_get_output_headers(req),
	    "Server", "green httpd");
	evhttp_send_reply(req, 200, "OK", evb);
	
	if (evhttp_request_get_command(req) != EVHTTP_REQ_GET) {
	    evhttp_clear_headers(&params);
        free(data);
	}
}
Esempio n. 30
0
static void static_dump_request_cb(struct evhttp_request *req, void *arg)
{

	const char *cmdtype;
	struct evkeyvalq *headers;
	struct evkeyval *header;
	struct evbuffer *buf;


	switch (evhttp_request_get_command(req)) {
		case EVHTTP_REQ_GET:
			cmdtype = "GET";
		break;
		case EVHTTP_REQ_POST:
			cmdtype = "POST";
		break;
		default:
			cmdtype = "unknown";
		break;
	}
	printf("Received a %s request for %s\nHeaders:\n",
	    cmdtype, evhttp_request_get_uri(req));

	headers = evhttp_request_get_input_headers(req);
	for (header = headers->tqh_first; header;
	    header = header->next.tqe_next) {
		printf("  %s: %s\n", header->key, header->value);
	}

	buf = evhttp_request_get_input_buffer(req);
	puts("Input data: <<<");
	printf("len:%d", evbuffer_get_length(buf));

	/*
	while (evbuffer_get_length(buf)) {
		int n;
		char cbuf[128];
		n = evbuffer_remove(buf, cbuf, sizeof(buf)-1);
		if (n > 0)
			(void) fwrite(cbuf, 1, n, stdout);
	}
	puts(">>>");
	*/

	//get params
	struct evkeyvalq *query_params_ptr = calloc(sizeof(struct evkeyvalq), 1);
	getParams(req, query_params_ptr);
	char *test = NULL;
	test = getParam(query_params_ptr, "test");
	if (test != NULL) {
		fprintf(stderr, "param test: %s", test);
	}
	evhttp_clear_headers(query_params_ptr);
	free(test);


	//post params
	struct evkeyvalq *post_params_ptr = calloc(sizeof(struct evkeyvalq), 1);
	postParams(req, post_params_ptr);
	char *name = NULL;
	name = postParam(post_params_ptr, "name");
	if (name != NULL) {
		fprintf(stderr, "param name: %s", name);
	}

	evhttp_clear_headers(post_params_ptr);
	free(name);

	evhttp_send_reply(req, 200, "OK", NULL);

	//evhttp_request_free(req);
}