/**
* Responder thread main body.
* Collects responses from the opensrf network and relays them to the
* websocket caller.
*/
void* APR_THREAD_FUNC osrf_responder_thread_main(apr_thread_t *thread, void *data) {
transport_message *tmsg;
while (1) {
if (apr_thread_mutex_unlock(trans->mutex) != APR_SUCCESS) {
osrfLogError(OSRF_LOG_MARK, "WS error un-locking thread mutex");
return NULL;
}
// wait for a response
tmsg = client_recv(osrf_handle, -1);
if (!tmsg) continue; // interrupt
if (trans->client_connected) {
if (apr_thread_mutex_lock(trans->mutex) != APR_SUCCESS) {
osrfLogError(OSRF_LOG_MARK, "WS error locking thread mutex");
return NULL;
}
osrfLogForceXid(tmsg->osrf_xid);
osrf_responder_thread_main_body(tmsg);
last_activity_time = time(NULL);
}
message_free(tmsg);
}
return NULL;
}
void server_process(Peer *peer)
{
struct sockaddr_in cli_addr;
int i,nfds;
int socket;
int cli_len = sizeof(cli_addr);
nfds = epoll_wait(g_epoll_fd,g_events,MAX_EVENTS,100); /* timeout 100ms */
if(nfds == 0) return; /* no event , no work */
if(nfds < 0)
{
printf("[ETEST] epoll wait error\n");
return; /* return but this is epoll wait error */
}
for( i = 0 ; i < nfds ; i++ )
{
if(g_events[i].data.fd == g_svr_sockfd)
{
socket = accept(g_svr_sockfd,
(struct sockaddr *)&cli_addr,
(socklen_t *)&cli_len);
if(socket < 0) /* accept error */
{
}
else
{
printf("[ETEST][Accpet] New client connected. fd:%d,ip:%s\n",
socket,
inet_ntoa(cli_addr.sin_addr));
userpool_add(socket,
inet_ntoa(cli_addr.sin_addr),
peer);
epoll_cli_add(socket);
}
continue; /* next fd */
}
/* if not server socket ,
this socket is for client socket,
so we read it */
// 이벤트가 발생한 소켓에 대해서 데이터를 읽어들인다.
// Thread Creadte
printf("Event Create \n");
client_recv(g_events[i].data.fd, peer);
} /* end of for 0-nfds */
}
void server_process(Peer *peer)
{
struct sockaddr_in cli_addr;
int i,nfds;
int socket;
int cli_len = sizeof(cli_addr);
nfds = epoll_wait(g_epoll_fd,g_events,MAX_EVENTS,100); /* timeout 100ms */
if(nfds == 0) return; /* no event , no work */
if(nfds < 0)
{
printf("[ETEST] epoll wait error\n");
return; /* return but this is epoll wait error */
}
for( i = 0 ; i < nfds ; i++ )
{
if(g_events[i].data.fd == g_svr_sockfd)
{
socket = accept(g_svr_sockfd, (struct sockaddr *)&cli_addr, (socklen_t *)&cli_len);
if(socket < 0) /* accept error */
{
printf("Accept Error \n");
}
else
{
// Mac Address Add
int flag = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flag|O_NONBLOCK);
epoll_cli_add(socket);
printf("New client connected and Set Async fd : %d, ip : %s \n", socket , inet_ntoa(cli_addr.sin_addr));
userpool_add(socket, inet_ntoa(cli_addr.sin_addr), peer);
}
continue;
}
// 이벤트가 발생한 소켓에 대해서 데이터를 읽어들인다.
int flag = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flag|O_NONBLOCK);
client_recv(g_events[i].data.fd, peer);
}
}
int main(int argc, char *argv[])
{
FILE *fh = NULL;
if (argc != 2) {
fprintf(stderr, "Please specify file to write to.\n");
return EXIT_FAILURE;
}
if (argc == 2) {
fh = fopen(argv[1], "w");
if (NULL == fh) {
fprintf(stderr, "Failure to open file.\n");
return EXIT_FAILURE;
}
}
int sock = client_init("225.1.1.1", 5555);
struct sample samples[SAMPLES_PER_FILE];
memset(samples, 0, sizeof(samples));
struct sample *cap = samples;
while (true) {
size_t len = client_recv(sock, (uint8_t *)cap,
SAMPLES_PER_CAPTURE * sizeof(*cap));
assert(SAMPLES_PER_CAPTURE * sizeof(*cap) == len);
cap += SAMPLES_PER_CAPTURE;
if (cap >= &samples[SAMPLES_PER_FILE]) {
// Write out the file with all the known samples.
fh = fopen(argv[1], "w");
for (int i = 0; i < ARRAY_LEN(samples); i++) {
fprintf(fh, "%f %03.4f\n", samples[i].t.tv_sec +
samples[i].t.tv_nsec / NSEC_PER_SEC,
((105.84 / 4096) * samples[i].d) / 0.1);
}
fclose(fh);
// Shift room for the new samples.
memset(samples, 0, sizeof(samples));
cap = samples;
}
}
return EXIT_SUCCESS;
}
static int
_gnutls_status_request_recv_params(gnutls_session_t session,
const uint8_t * data, size_t size)
{
extension_priv_data_t epriv;
status_request_ext_st *priv;
int ret;
ret = _gnutls_ext_get_session_data(session,
GNUTLS_EXTENSION_STATUS_REQUEST,
&epriv);
if (ret < 0 || epriv.ptr == NULL) /* it is ok not to have it */
return 0;
priv = epriv.ptr;
if (session->security_parameters.entity == GNUTLS_CLIENT)
return client_recv(session, priv, data, size);
return server_recv(session, priv, data, size);
}
void *client_recv1(void *gui){
while(1){
char buff[MAXLINE];
int bytes = client_recv(((Gui*)gui)->sockfd, buff);
buff[bytes] = '\0';
if (buff[0] != '\0'){
gchar *new_tab = "> ";
add_to_text(gui, new_tab);
add_to_text(gui, buff);
gchar *new_line = "\n";
add_to_text(gui, new_line);
}
buff[0] = '\0';
sleep(.1);
}
}
/**
@brief Read and process available transport_messages for a transport_client.
@param client Pointer to the transport_client whose socket is to be read.
@param timeout How many seconds to wait for the first message.
@param msg_received A pointer through which to report whether a message was received.
@return 0 upon success (even if a timeout occurs), or -1 upon failure.
Read and process all available transport_messages from the socket of the specified
transport_client. Pass each one through osrf_stack_transport().
The timeout applies only to the first message. Any subsequent messages must be
available immediately. Don't wait for them, even if the timeout has not expired. In
theory, a sufficiently large backlog of input messages could keep you working past the
nominal expiration of the timeout.
The @a msg_received parameter points to an int owned by the calling code and used as
a boolean. Set it to true if you receive at least one transport_message, or to false
if you don't. A timeout is not treated as an error; it just means you must set that
boolean to false.
*/
int osrf_stack_process( transport_client* client, int timeout, int* msg_received ) {
if( !client ) return -1;
transport_message* msg = NULL;
if(msg_received) *msg_received = 0;
// Loop through the available input messages
while( (msg = client_recv( client, timeout )) ) {
if(msg_received) *msg_received = 1;
osrfLogDebug( OSRF_LOG_MARK, "Received message from transport code from %s", msg->sender );
osrf_stack_transport_handler( msg, NULL );
timeout = 0;
}
if( client->error ) {
osrfLogWarning(OSRF_LOG_MARK, "transport_client had trouble reading from the socket..");
return -1;
}
if( ! client_connected( client ) ) return -1;
return 0;
}
static int osrfHttpTranslatorProcess(osrfHttpTranslator* trans) {
if(trans->body == NULL)
return HTTP_BAD_REQUEST;
if(!osrfHttpTranslatorSetTo(trans))
return HTTP_BAD_REQUEST;
char* jsonBody = osrfHttpTranslatorParseRequest(trans);
if (NULL == jsonBody)
return HTTP_BAD_REQUEST;
while(client_recv(trans->handle, 0))
continue; // discard any old status messages in the recv queue
// send the message to the recipient
transport_message* tmsg = message_init(
jsonBody, NULL, trans->thread, trans->recipient, NULL);
message_set_osrf_xid(tmsg, osrfLogGetXid());
client_send_message(trans->handle, tmsg);
message_free(tmsg);
free(jsonBody);
if(trans->disconnectOnly) {
osrfLogDebug(OSRF_LOG_MARK, "exiting early on disconnect");
osrfCacheRemove(trans->thread);
return OK;
}
// process the response from the opensrf service
int firstWrite = 1;
while(!trans->complete) {
transport_message* msg = client_recv(trans->handle, trans->timeout);
if(trans->handle->error) {
osrfLogError(OSRF_LOG_MARK, "Transport error");
osrfCacheRemove(trans->thread);
return HTTP_INTERNAL_SERVER_ERROR;
}
if(msg == NULL)
return HTTP_GATEWAY_TIME_OUT;
if(msg->is_error) {
osrfLogError(OSRF_LOG_MARK, "XMPP message resulted in error code %d", msg->error_code);
osrfCacheRemove(trans->thread);
return HTTP_NOT_FOUND;
}
if(!osrfHttpTranslatorCheckStatus(trans, msg))
continue;
if(firstWrite) {
osrfHttpTranslatorInitHeaders(trans, msg);
if(trans->connecting)
osrfHttpTranslatorCacheSession(trans, msg->sender);
firstWrite = 0;
}
if(trans->multipart) {
osrfHttpTranslatorWriteChunk(trans, msg);
if(trans->connectOnly)
break;
} else {
if(!trans->messages)
trans->messages = osrfNewList();
osrfListPush(trans->messages, msg->body);
if(trans->complete || trans->connectOnly) {
growing_buffer* buf = buffer_init(128);
unsigned int i;
OSRF_BUFFER_ADD(buf, osrfListGetIndex(trans->messages, 0));
for(i = 1; i < trans->messages->size; i++) {
buffer_chomp(buf); // chomp off the closing array bracket
char* body = osrfListGetIndex(trans->messages, i);
char newbuf[strlen(body)];
sprintf(newbuf, "%s", body+1); // chomp off the opening array bracket
OSRF_BUFFER_ADD_CHAR(buf, ',');
OSRF_BUFFER_ADD(buf, newbuf);
}
ap_rputs(buf->buf, trans->apreq);
buffer_free(buf);
}
}
}
if(trans->disconnecting) // DISCONNECT within a multi-message batch
osrfCacheRemove(trans->thread);
return OK;
}
static int rping_cq_event_handler(struct rping_cb *cb)
{
struct ibv_wc wc;
struct ibv_recv_wr *bad_wr;
int ret;
int flushed = 0;
while ((ret = ibv_poll_cq(cb->cq, 1, &wc)) == 1) {
ret = 0;
if (wc.status) {
if (wc.status == IBV_WC_WR_FLUSH_ERR) {
flushed = 1;
continue;
}
fprintf(stderr,
"cq completion failed status %d\n",
wc.status);
ret = -1;
goto error;
}
switch (wc.opcode) {
case IBV_WC_SEND:
DEBUG_LOG("send completion\n");
break;
case IBV_WC_RDMA_WRITE:
DEBUG_LOG("rdma write completion\n");
cb->state = RDMA_WRITE_COMPLETE;
sem_post(&cb->sem);
break;
case IBV_WC_RDMA_READ:
DEBUG_LOG("rdma read completion\n");
cb->state = RDMA_READ_COMPLETE;
sem_post(&cb->sem);
break;
case IBV_WC_RECV:
DEBUG_LOG("recv completion\n");
ret = cb->server ? server_recv(cb, &wc) :
client_recv(cb, &wc);
if (ret) {
fprintf(stderr, "recv wc error: %d\n", ret);
goto error;
}
ret = ibv_post_recv(cb->qp, &cb->rq_wr, &bad_wr);
if (ret) {
fprintf(stderr, "post recv error: %d\n", ret);
goto error;
}
sem_post(&cb->sem);
break;
default:
DEBUG_LOG("unknown!!!!! completion\n");
ret = -1;
goto error;
}
}
if (ret) {
fprintf(stderr, "poll error %d\n", ret);
goto error;
}
return flushed;
error:
cb->state = ERROR;
sem_post(&cb->sem);
return ret;
}
int main(int argc, char **argv) {
srand(time(NULL));
rand();
if (argc == 2 || argc == 3) {
char *hostname = argv[1];
int port = DEFAULT_PORT;
if (argc == 3) {
port = atoi(argv[2]);
}
db_disable();
client_enable();
client_connect(hostname, port);
client_start();
}
if (!glfwInit()) {
return -1;
}
create_window();
if (!window) {
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSwapInterval(VSYNC);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, on_key);
glfwSetMouseButtonCallback(window, on_mouse_button);
glfwSetScrollCallback(window, on_scroll);
#ifndef __APPLE__
if (glewInit() != GLEW_OK) {
return -1;
}
#endif
if (db_init()) {
return -1;
}
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_INVERT);
glClearColor(0.53, 0.81, 0.92, 1.00);
GLuint texture;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
load_png_texture("texture.png");
GLuint block_program = load_program(
"shaders/block_vertex.glsl", "shaders/block_fragment.glsl");
GLuint matrix_loc = glGetUniformLocation(block_program, "matrix");
GLuint camera_loc = glGetUniformLocation(block_program, "camera");
GLuint sampler_loc = glGetUniformLocation(block_program, "sampler");
GLuint timer_loc = glGetUniformLocation(block_program, "timer");
GLuint position_loc = glGetAttribLocation(block_program, "position");
GLuint normal_loc = glGetAttribLocation(block_program, "normal");
GLuint uv_loc = glGetAttribLocation(block_program, "uv");
GLuint line_program = load_program(
"shaders/line_vertex.glsl", "shaders/line_fragment.glsl");
GLuint line_matrix_loc = glGetUniformLocation(line_program, "matrix");
GLuint line_position_loc = glGetAttribLocation(line_program, "position");
GLuint item_position_buffer = 0;
GLuint item_normal_buffer = 0;
GLuint item_uv_buffer = 0;
int previous_block_type = 0;
Chunk chunks[MAX_CHUNKS];
int chunk_count = 0;
Player players[MAX_PLAYERS];
int player_count = 0;
FPS fps = {0, 0};
float matrix[16];
float x = (rand_double() - 0.5) * 10000;
float z = (rand_double() - 0.5) * 10000;
float y = 0;
float dy = 0;
float rx = 0;
float ry = 0;
double px = 0;
double py = 0;
int loaded = db_load_state(&x, &y, &z, &rx, &ry);
ensure_chunks(chunks, &chunk_count,
floorf(roundf(x) / CHUNK_SIZE),
floorf(roundf(z) / CHUNK_SIZE), 1);
if (!loaded) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
glfwGetCursorPos(window, &px, &py);
double previous = glfwGetTime();
while (!glfwWindowShouldClose(window)) {
update_fps(&fps, SHOW_FPS);
double now = glfwGetTime();
double dt = MIN(now - previous, 0.2);
previous = now;
if (exclusive && (px || py)) {
double mx, my;
glfwGetCursorPos(window, &mx, &my);
float m = 0.0025;
rx += (mx - px) * m;
ry -= (my - py) * m;
if (rx < 0) {
rx += RADIANS(360);
}
if (rx >= RADIANS(360)){
rx -= RADIANS(360);
}
ry = MAX(ry, -RADIANS(90));
ry = MIN(ry, RADIANS(90));
px = mx;
py = my;
}
else {
glfwGetCursorPos(window, &px, &py);
}
int sz = 0;
int sx = 0;
ortho = glfwGetKey(window, 'F');
fov = glfwGetKey(window, GLFW_KEY_LEFT_SHIFT) ? 15.0 : 65.0;
if (glfwGetKey(window, 'Q')) break;
if (glfwGetKey(window, 'W')) sz--;
if (glfwGetKey(window, 'S')) sz++;
if (glfwGetKey(window, 'A')) sx--;
if (glfwGetKey(window, 'D')) sx++;
float m = dt * 1.0;
if (glfwGetKey(window, GLFW_KEY_LEFT)) rx -= m;
if (glfwGetKey(window, GLFW_KEY_RIGHT)) rx += m;
if (glfwGetKey(window, GLFW_KEY_UP)) ry += m;
if (glfwGetKey(window, GLFW_KEY_DOWN)) ry -= m;
float vx, vy, vz;
get_motion_vector(flying, sz, sx, rx, ry, &vx, &vy, &vz);
if (glfwGetKey(window, GLFW_KEY_SPACE)) {
if (flying) {
vy = 1;
}
else if (dy == 0) {
dy = 8;
}
}
if (glfwGetKey(window, 'Z')) {
vx = -1; vy = 0; vz = 0;
}
if (glfwGetKey(window, 'X')) {
vx = 1; vy = 0; vz = 0;
}
if (glfwGetKey(window, 'C')) {
vx = 0; vy = -1; vz = 0;
}
if (glfwGetKey(window, 'V')) {
vx = 0; vy = 1; vz = 0;
}
if (glfwGetKey(window, 'B')) {
vx = 0; vy = 0; vz = -1;
}
if (glfwGetKey(window, 'N')) {
vx = 0; vy = 0; vz = 1;
}
float speed = flying ? 20 : 5;
int step = 8;
float ut = dt / step;
vx = vx * ut * speed;
vy = vy * ut * speed;
vz = vz * ut * speed;
for (int i = 0; i < step; i++) {
if (flying) {
dy = 0;
}
else {
dy -= ut * 25;
dy = MAX(dy, -250);
}
x += vx;
y += vy + dy * ut;
z += vz;
if (collide(chunks, chunk_count, 2, &x, &y, &z)) {
dy = 0;
}
}
if (y < 0) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
for (int i = 0; i < chunk_count; i++) {
Chunk *chunk = chunks + i;
chunk->dirty = 0;
}
if (left_click) {
left_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
&hx, &hy, &hz);
if (hy > 0 && is_destructable(hw)) {
set_block(chunks, chunk_count, hx, hy, hz, 0, 1);
}
}
if (right_click) {
right_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 1, x, y, z, rx, ry,
&hx, &hy, &hz);
if (is_obstacle(hw)) {
if (!player_intersects_block(2, x, y, z, hx, hy, hz)) {
set_block(chunks, chunk_count, hx, hy, hz, block_type, 1);
}
}
}
if (middle_click) {
middle_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
&hx, &hy, &hz);
if (is_selectable(hw)) {
block_type = hw;
}
}
if (teleport) {
teleport = 0;
if (player_count) {
int index = rand_int(player_count);
Player *player = players + index;
x = player->x;
y = player->y;
z = player->z;
rx = player->rx;
ry = player->ry;
ensure_chunks(chunks, &chunk_count,
floorf(roundf(x) / CHUNK_SIZE),
floorf(roundf(z) / CHUNK_SIZE), 1);
}
}
client_position(x, y, z, rx, ry);
char buffer[RECV_BUFFER_SIZE];
while (client_recv(buffer, RECV_BUFFER_SIZE)) {
float ux, uy, uz, urx, ury;
if (sscanf(buffer, "U,%*d,%f,%f,%f,%f,%f",
&ux, &uy, &uz, &urx, &ury) == 5)
{
x = ux; y = uy; z = uz; rx = urx; ry = ury;
ensure_chunks(chunks, &chunk_count,
floorf(roundf(x) / CHUNK_SIZE),
floorf(roundf(z) / CHUNK_SIZE), 1);
y = highest_block(chunks, chunk_count, x, z) + 2;
}
int bx, by, bz, bw;
if (sscanf(buffer, "B,%*d,%*d,%d,%d,%d,%d",
&bx, &by, &bz, &bw) == 4)
{
set_block(chunks, chunk_count, bx, by, bz, bw, 0);
if ((int)roundf(x) == bx && (int)roundf(z) == bz) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
}
int pid;
float px, py, pz, prx, pry;
if (sscanf(buffer, "P,%d,%f,%f,%f,%f,%f",
&pid, &px, &py, &pz, &prx, &pry) == 6)
{
Player *player = find_player(players, player_count, pid);
if (!player && player_count < MAX_PLAYERS) {
player = players + player_count;
player_count++;
player->id = pid;
player->position_buffer = 0;
player->normal_buffer = 0;
player->uv_buffer = 0;
printf("%d other players are online\n", player_count);
}
if (player) {
update_player(player, px, py, pz, prx, pry);
}
}
if (sscanf(buffer, "D,%d", &pid) == 1) {
delete_player(players, &player_count, pid);
printf("%d other players are online\n", player_count);
}
}
for (int i = 0; i < chunk_count; i++) {
Chunk *chunk = chunks + i;
if (chunk->dirty) {
update_chunk(chunk);
}
}
int p = floorf(roundf(x) / CHUNK_SIZE);
int q = floorf(roundf(z) / CHUNK_SIZE);
ensure_chunks(chunks, &chunk_count, p, q, 0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
update_matrix_3d(matrix, x, y, z, rx, ry);
// render chunks
glUseProgram(block_program);
glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
glUniform3f(camera_loc, x, y, z);
glUniform1i(sampler_loc, 0);
glUniform1f(timer_loc, glfwGetTime());
for (int i = 0; i < chunk_count; i++) {
Chunk *chunk = chunks + i;
if (chunk_distance(chunk, p, q) > RENDER_CHUNK_RADIUS) {
continue;
}
if (!chunk_visible(chunk, matrix)) {
continue;
}
draw_chunk(chunk, position_loc, normal_loc, uv_loc);
}
// render players
for (int i = 0; i < player_count; i++) {
Player *player = players + i;
draw_player(player, position_loc, normal_loc, uv_loc);
}
// render focused block wireframe
int hx, hy, hz;
int hw = hit_test(
chunks, chunk_count, 0, x, y, z, rx, ry, &hx, &hy, &hz);
if (is_obstacle(hw)) {
glUseProgram(line_program);
glLineWidth(1);
glEnable(GL_COLOR_LOGIC_OP);
glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
GLuint cube_buffer = make_cube_buffer(hx, hy, hz, 0.51);
draw_lines(cube_buffer, line_position_loc, 3, 48);
glDeleteBuffers(1, &cube_buffer);
glDisable(GL_COLOR_LOGIC_OP);
}
update_matrix_2d(matrix);
// render crosshairs
glUseProgram(line_program);
glLineWidth(4);
glEnable(GL_COLOR_LOGIC_OP);
glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
GLuint line_buffer = make_line_buffer();
draw_lines(line_buffer, line_position_loc, 2, 4);
glDeleteBuffers(1, &line_buffer);
glDisable(GL_COLOR_LOGIC_OP);
// render selected item
update_matrix_item(matrix);
if (block_type != previous_block_type) {
previous_block_type = block_type;
make_single_cube(
&item_position_buffer, &item_normal_buffer, &item_uv_buffer,
0, 0, 0, 0.5, block_type);
}
glUseProgram(block_program);
glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
glUniform3f(camera_loc, 0, 0, 5);
glUniform1i(sampler_loc, 0);
glUniform1f(timer_loc, glfwGetTime());
glDisable(GL_DEPTH_TEST);
draw_single_cube(
item_position_buffer, item_normal_buffer, item_uv_buffer,
position_loc, normal_loc, uv_loc);
glEnable(GL_DEPTH_TEST);
glfwSwapBuffers(window);
glfwPollEvents();
}
client_stop();
db_save_state(x, y, z, rx, ry);
db_close();
glfwTerminate();
return 0;
}
void *client_fn(LTP_ATTRIBUTE_UNUSED void *arg)
{
char buf[server_msg_size];
int cfd, i;
intptr_t err = 0;
/* connect & send requests */
cfd = client_connect_send(client_msg, client_msg_size);
if (cfd == -1) {
err = errno;
goto out;
}
if (client_recv(&cfd, buf)) {
err = errno;
goto out;
}
for (i = 1; i < client_max_requests; ++i) {
/* check connection, it can be closed */
int ret = 0;
if (cfd != -1)
ret = recv(cfd, buf, 1, MSG_DONTWAIT);
if (ret == 0) {
/* try to reconnect and send */
if (cfd != -1)
SAFE_CLOSE(cleanup, cfd);
cfd = client_connect_send(client_msg, client_msg_size);
if (cfd == -1) {
err = errno;
goto out;
}
if (client_recv(&cfd, buf)) {
err = errno;
break;
}
continue;
} else if (ret > 0) {
err = EMSGSIZE;
break;
}
if (verbose) {
tst_resm_hexd(TINFO, client_msg, client_msg_size,
"try to send msg[%d]", i);
}
if (send(cfd, client_msg, client_msg_size,
MSG_NOSIGNAL) != client_msg_size) {
err = ECOMM;
break;
}
if (client_recv(&cfd, buf)) {
err = errno;
break;
}
}
if (cfd != -1)
SAFE_CLOSE(cleanup, cfd);
out:
return (void *) err;
}
/**
* User thread responsible for handling individual clients
* @param arg Structure to use to process the thread
*/
void *user_thread( void *arg ) {
User user = new_user( ((Environment)arg)->client );
Management manager = ((Environment)arg)->manager;
// increase thread count
manager_up_thread( manager, pthread_self() );
// lock user for now
user_lock( user );
// add the user to the list of users
manager_add_user( manager, user );
// turn client on
client_ok( user->client );
// ready user for commo
user_unlock( user );
/* ---------------------------------------------
* Login screen
*/
Room login_room = room_get( manager->rooms, 0 );
if( login_room == NULL ){
printf("Error getting login room\n");
//return 0;
}
char_set_room( user->parent->character, login_room );
// have a look
action_look( NULL, user, manager );
// client_prompt( )
// accept input
// initialize
int buff_len = 256;
char *buff = (char *) malloc( buff_len );
memset( buff, 0, 256 );
if( buff == NULL ){
perror("client thread recv buffer malloc");
return NULL;
}
// user response loop
while( manager->cease != 1 && (user->flags & USER_FLAG_EXIT) == 0 ){
// receive response from client
int length = client_recv(
user->client,
&buff,
&buff_len );
// handle response
if( buff != NULL && length > 0 ){
// parse the response for actionable text
action_parse_response(
buff, // buffer with response
length, // length of response
user, // user making response
manager ); // manager
// reset response
memset(buff,0,length);
} else {
// nothing going on, yield
sched_yield();
}
}
free( buff );
// remove from manager list
manager_remove_user( manager, user );
// lock user for this
user_lock( user );
// close and destory all structs
// manually manage this part
close_client( user->client );
destroy_client( user->client );
// user gone from manager so safe to unlock a head
user_unlock( user );
// now destroy
destroy_user( user );
free( ((Environment)arg) );
// decrease thread count
manager_down_thread( manager, pthread_self() );
pthread_exit( 0 );
return NULL;
}
static int cq_event_handler(struct thread_data *td, enum ibv_wc_opcode opcode)
{
struct rdmaio_data *rd = td->io_ops->data;
struct ibv_wc wc;
struct rdma_io_u_data *r_io_u_d;
int ret;
int compevnum = 0;
int i;
while ((ret = ibv_poll_cq(rd->cq, 1, &wc)) == 1) {
ret = 0;
compevnum++;
if (wc.status) {
log_err("fio: cq completion status %d(%s)\n",
wc.status, ibv_wc_status_str(wc.status));
return -1;
}
switch (wc.opcode) {
case IBV_WC_RECV:
if (rd->is_client == 1)
ret = client_recv(td, &wc);
else
ret = server_recv(td, &wc);
if (ret)
return -1;
if (wc.wr_id == FIO_RDMA_MAX_IO_DEPTH)
break;
for (i = 0; i < rd->io_u_flight_nr; i++) {
r_io_u_d = rd->io_us_flight[i]->engine_data;
if (wc.wr_id == r_io_u_d->rq_wr.wr_id) {
rd->io_us_flight[i]->resid =
rd->io_us_flight[i]->buflen
- wc.byte_len;
rd->io_us_flight[i]->error = 0;
rd->io_us_completed[rd->
io_u_completed_nr]
= rd->io_us_flight[i];
rd->io_u_completed_nr++;
break;
}
}
if (i == rd->io_u_flight_nr)
log_err("fio: recv wr %" PRId64 " not found\n",
wc.wr_id);
else {
/* put the last one into middle of the list */
rd->io_us_flight[i] =
rd->io_us_flight[rd->io_u_flight_nr - 1];
rd->io_u_flight_nr--;
}
break;
case IBV_WC_SEND:
case IBV_WC_RDMA_WRITE:
case IBV_WC_RDMA_READ:
if (wc.wr_id == FIO_RDMA_MAX_IO_DEPTH)
break;
for (i = 0; i < rd->io_u_flight_nr; i++) {
r_io_u_d = rd->io_us_flight[i]->engine_data;
if (wc.wr_id == r_io_u_d->sq_wr.wr_id) {
rd->io_us_completed[rd->
io_u_completed_nr]
= rd->io_us_flight[i];
rd->io_u_completed_nr++;
break;
}
}
if (i == rd->io_u_flight_nr)
log_err("fio: send wr %" PRId64 " not found\n",
wc.wr_id);
else {
/* put the last one into middle of the list */
rd->io_us_flight[i] =
rd->io_us_flight[rd->io_u_flight_nr - 1];
rd->io_u_flight_nr--;
}
break;
default:
log_info("fio: unknown completion event %d\n",
wc.opcode);
return -1;
}
rd->cq_event_num++;
}
if (ret) {
log_err("fio: poll error %d\n", ret);
return 1;
}
return compevnum;
}
int main(int argc, char **argv) {
srand(time(NULL));
rand();
if (argc == 2 || argc == 3) {
char *hostname = argv[1];
int port = DEFAULT_PORT;
if (argc == 3) {
port = atoi(argv[2]);
}
db_disable();
client_enable();
client_connect(hostname, port);
client_start();
}
if (!glfwInit()) {
return -1;
}
create_window();
if (!window) {
glfwTerminate();
return -1;
}
glfwMakeContextCurrent(window);
glfwSwapInterval(VSYNC);
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
glfwSetKeyCallback(window, on_key);
glfwSetCharCallback(window, on_char);
glfwSetMouseButtonCallback(window, on_mouse_button);
glfwSetScrollCallback(window, on_scroll);
#ifndef __APPLE__
if (glewInit() != GLEW_OK) {
return -1;
}
#endif
if (db_init()) {
return -1;
}
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_INVERT);
glClearColor(0.53, 0.81, 0.92, 1.00);
GLuint texture;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
load_png_texture("texture.png");
GLuint font;
glGenTextures(1, &font);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, font);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
load_png_texture("font.png");
GLuint block_program = load_program(
"shaders/block_vertex.glsl", "shaders/block_fragment.glsl");
GLuint matrix_loc = glGetUniformLocation(block_program, "matrix");
GLuint camera_loc = glGetUniformLocation(block_program, "camera");
GLuint sampler_loc = glGetUniformLocation(block_program, "sampler");
GLuint timer_loc = glGetUniformLocation(block_program, "timer");
GLuint position_loc = glGetAttribLocation(block_program, "position");
GLuint normal_loc = glGetAttribLocation(block_program, "normal");
GLuint uv_loc = glGetAttribLocation(block_program, "uv");
GLuint line_program = load_program(
"shaders/line_vertex.glsl", "shaders/line_fragment.glsl");
GLuint line_matrix_loc = glGetUniformLocation(line_program, "matrix");
GLuint line_position_loc = glGetAttribLocation(line_program, "position");
GLuint text_program = load_program(
"shaders/text_vertex.glsl", "shaders/text_fragment.glsl");
GLuint text_matrix_loc = glGetUniformLocation(text_program, "matrix");
GLuint text_sampler_loc = glGetUniformLocation(text_program, "sampler");
GLuint text_position_loc = glGetAttribLocation(text_program, "position");
GLuint text_uv_loc = glGetAttribLocation(text_program, "uv");
GLuint item_position_buffer = 0;
GLuint item_normal_buffer = 0;
GLuint item_uv_buffer = 0;
int previous_block_type = 0;
char messages[MAX_MESSAGES][TEXT_BUFFER_SIZE] = {0};
int message_index = 0;
Chunk chunks[MAX_CHUNKS];
int chunk_count = 0;
Player players[MAX_PLAYERS];
int player_count = 0;
FPS fps = {0, 0};
float matrix[16];
float x = (rand_double() - 0.5) * 10000;
float z = (rand_double() - 0.5) * 10000;
float y = 0;
float dy = 0;
float rx = 0;
float ry = 0;
double px = 0;
double py = 0;
int loaded = db_load_state(&x, &y, &z, &rx, &ry);
ensure_chunks(chunks, &chunk_count, x, y, z, 1);
if (!loaded) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
glfwGetCursorPos(window, &px, &py);
double previous = glfwGetTime();
while (!glfwWindowShouldClose(window)) {
int width, height;
glfwGetFramebufferSize(window, &width, &height);
glViewport(0, 0, width, height);
update_fps(&fps, SHOW_FPS);
double now = glfwGetTime();
double dt = MIN(now - previous, 0.2);
previous = now;
if (exclusive && (px || py)) {
double mx, my;
glfwGetCursorPos(window, &mx, &my);
float m = 0.0025;
rx += (mx - px) * m;
ry -= (my - py) * m;
if (rx < 0) {
rx += RADIANS(360);
}
if (rx >= RADIANS(360)){
rx -= RADIANS(360);
}
ry = MAX(ry, -RADIANS(90));
ry = MIN(ry, RADIANS(90));
px = mx;
py = my;
}
else {
glfwGetCursorPos(window, &px, &py);
}
int sz = 0;
int sx = 0;
if (!typing) {
float m = dt * 1.0;
ortho = glfwGetKey(window, CRAFT_KEY_ORTHO);
fov = glfwGetKey(window, CRAFT_KEY_ZOOM) ? 15.0 : 65.0;
if (glfwGetKey(window, CRAFT_KEY_QUIT)) break;
if (glfwGetKey(window, CRAFT_KEY_FORWARD)) sz--;
if (glfwGetKey(window, CRAFT_KEY_BACKWARD)) sz++;
if (glfwGetKey(window, CRAFT_KEY_LEFT)) sx--;
if (glfwGetKey(window, CRAFT_KEY_RIGHT)) sx++;
if (glfwGetKey(window, GLFW_KEY_LEFT)) rx -= m;
if (glfwGetKey(window, GLFW_KEY_RIGHT)) rx += m;
if (glfwGetKey(window, GLFW_KEY_UP)) ry += m;
if (glfwGetKey(window, GLFW_KEY_DOWN)) ry -= m;
}
float vx, vy, vz;
get_motion_vector(flying, sz, sx, rx, ry, &vx, &vy, &vz);
if (!typing) {
if (glfwGetKey(window, CRAFT_KEY_JUMP)) {
if (flying) {
vy = 1;
}
else if (dy == 0) {
dy = 8;
}
}
if (glfwGetKey(window, CRAFT_KEY_XM)) {
vx = -1; vy = 0; vz = 0;
}
if (glfwGetKey(window, CRAFT_KEY_XP)) {
vx = 1; vy = 0; vz = 0;
}
if (glfwGetKey(window, CRAFT_KEY_YM)) {
vx = 0; vy = -1; vz = 0;
}
if (glfwGetKey(window, CRAFT_KEY_YP)) {
vx = 0; vy = 1; vz = 0;
}
if (glfwGetKey(window, CRAFT_KEY_ZM)) {
vx = 0; vy = 0; vz = -1;
}
if (glfwGetKey(window, CRAFT_KEY_ZP)) {
vx = 0; vy = 0; vz = 1;
}
}
float speed = flying ? 20 : 5;
int step = 8;
float ut = dt / step;
vx = vx * ut * speed;
vy = vy * ut * speed;
vz = vz * ut * speed;
for (int i = 0; i < step; i++) {
if (flying) {
dy = 0;
}
else {
dy -= ut * 25;
dy = MAX(dy, -250);
}
x += vx;
y += vy + dy * ut;
z += vz;
if (collide(chunks, chunk_count, 2, &x, &y, &z)) {
dy = 0;
}
}
if (y < 0) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
if (left_click) {
left_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
&hx, &hy, &hz);
if (hy > 0 && is_destructable(hw)) {
set_block(chunks, chunk_count, hx, hy, hz, 0);
int above = get_block(chunks, chunk_count, hx, hy + 1, hz);
if (is_plant(above)) {
set_block(chunks, chunk_count, hx, hy + 1, hz, 0);
}
}
}
if (right_click) {
right_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 1, x, y, z, rx, ry,
&hx, &hy, &hz);
if (is_obstacle(hw)) {
if (!player_intersects_block(2, x, y, z, hx, hy, hz)) {
set_block(chunks, chunk_count, hx, hy, hz, block_type);
}
}
}
if (middle_click) {
middle_click = 0;
int hx, hy, hz;
int hw = hit_test(chunks, chunk_count, 0, x, y, z, rx, ry,
&hx, &hy, &hz);
if (is_selectable(hw)) {
block_type = hw;
}
}
if (teleport) {
teleport = 0;
if (player_count) {
int index = rand_int(player_count);
Player *player = players + index;
x = player->x; y = player->y; z = player->z;
rx = player->rx; ry = player->ry;
ensure_chunks(chunks, &chunk_count, x, y, z, 1);
}
}
client_position(x, y, z, rx, ry);
char buffer[RECV_BUFFER_SIZE];
while (client_recv(buffer, RECV_BUFFER_SIZE)) {
float ux, uy, uz, urx, ury;
if (sscanf(buffer, "U,%*d,%f,%f,%f,%f,%f",
&ux, &uy, &uz, &urx, &ury) == 5)
{
x = ux; y = uy; z = uz; rx = urx; ry = ury;
ensure_chunks(chunks, &chunk_count, x, y, z, 1);
y = highest_block(chunks, chunk_count, x, z) + 2;
}
int bp, bq, bx, by, bz, bw;
if (sscanf(buffer, "B,%d,%d,%d,%d,%d,%d",
&bp, &bq, &bx, &by, &bz, &bw) == 6)
{
_set_block(chunks, chunk_count, bp, bq, bx, by, bz, bw);
if (player_intersects_block(2, x, y, z, bx, by, bz)) {
y = highest_block(chunks, chunk_count, x, z) + 2;
}
}
int pid;
float px, py, pz, prx, pry;
if (sscanf(buffer, "P,%d,%f,%f,%f,%f,%f",
&pid, &px, &py, &pz, &prx, &pry) == 6)
{
Player *player = find_player(players, player_count, pid);
if (!player && player_count < MAX_PLAYERS) {
player = players + player_count;
player_count++;
player->id = pid;
player->position_buffer = 0;
player->normal_buffer = 0;
player->uv_buffer = 0;
}
if (player) {
update_player(player, px, py, pz, prx, pry);
}
}
if (sscanf(buffer, "D,%d", &pid) == 1) {
delete_player(players, &player_count, pid);
}
if (buffer[0] == 'T' && buffer[1] == ',') {
char *text = buffer + 2;
printf("%s\n", text);
snprintf(
messages[message_index], TEXT_BUFFER_SIZE, "%s", text);
message_index = (message_index + 1) % MAX_MESSAGES;
}
}
int p = chunked(x);
int q = chunked(z);
ensure_chunks(chunks, &chunk_count, x, y, z, 0);
// RENDER 3-D SCENE //
glClear(GL_COLOR_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
set_matrix_3d(matrix, width, height, x, y, z, rx, ry, fov, ortho);
// render chunks
glUseProgram(block_program);
glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
glUniform3f(camera_loc, x, y, z);
glUniform1i(sampler_loc, 0);
glUniform1f(timer_loc, glfwGetTime());
for (int i = 0; i < chunk_count; i++) {
Chunk *chunk = chunks + i;
if (chunk_distance(chunk, p, q) > RENDER_CHUNK_RADIUS) {
continue;
}
if (y < 100 && !chunk_visible(chunk, matrix)) {
continue;
}
draw_chunk(chunk, position_loc, normal_loc, uv_loc);
}
// render players
for (int i = 0; i < player_count; i++) {
Player *player = players + i;
draw_player(player, position_loc, normal_loc, uv_loc);
}
// render focused block wireframe
int hx, hy, hz;
int hw = hit_test(
chunks, chunk_count, 0, x, y, z, rx, ry, &hx, &hy, &hz);
if (is_obstacle(hw)) {
glUseProgram(line_program);
glLineWidth(1);
glEnable(GL_COLOR_LOGIC_OP);
glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
GLuint wireframe_buffer = gen_wireframe_buffer(hx, hy, hz, 0.51);
draw_lines(wireframe_buffer, line_position_loc, 3, 48);
glDeleteBuffers(1, &wireframe_buffer);
glDisable(GL_COLOR_LOGIC_OP);
}
// RENDER 2-D HUD PARTS //
glClear(GL_DEPTH_BUFFER_BIT);
set_matrix_2d(matrix, width, height);
// render crosshairs
glUseProgram(line_program);
glLineWidth(4);
glEnable(GL_COLOR_LOGIC_OP);
glUniformMatrix4fv(line_matrix_loc, 1, GL_FALSE, matrix);
GLuint crosshair_buffer = gen_crosshair_buffer(width, height);
draw_lines(crosshair_buffer, line_position_loc, 2, 4);
glDeleteBuffers(1, &crosshair_buffer);
glDisable(GL_COLOR_LOGIC_OP);
// render text
glUseProgram(text_program);
glUniformMatrix4fv(text_matrix_loc, 1, GL_FALSE, matrix);
glUniform1i(text_sampler_loc, 1);
char text_buffer[1024];
float ts = 12;
float tx = ts / 2;
float ty = height - ts;
snprintf(
text_buffer, 1024, "%d, %d, %.2f, %.2f, %.2f [%d, %d]",
p, q, x, y, z, player_count, chunk_count);
print(
text_position_loc, text_uv_loc,
tx, ty, ts, text_buffer);
for (int i = 0; i < MAX_MESSAGES; i++) {
int index = (message_index + i) % MAX_MESSAGES;
if (strlen(messages[index])) {
ty -= ts * 2;
print(
text_position_loc, text_uv_loc,
tx, ty, ts, messages[index]);
}
}
if (typing) {
ty -= ts * 2;
snprintf(text_buffer, 1024, "> %s", typing_buffer);
print(
text_position_loc, text_uv_loc,
tx, ty, ts, text_buffer);
}
// RENDER 3-D HUD PARTS //
set_matrix_item(matrix, width, height);
// render selected item
if (block_type != previous_block_type) {
previous_block_type = block_type;
if (is_plant(block_type)) {
gen_plant_buffers(
&item_position_buffer, &item_normal_buffer, &item_uv_buffer,
0, 0, 0, 0.5, block_type);
}
else {
gen_cube_buffers(
&item_position_buffer, &item_normal_buffer, &item_uv_buffer,
0, 0, 0, 0.5, block_type);
}
}
glUseProgram(block_program);
glUniformMatrix4fv(matrix_loc, 1, GL_FALSE, matrix);
glUniform3f(camera_loc, 0, 0, 5);
glUniform1i(sampler_loc, 0);
glUniform1f(timer_loc, glfwGetTime());
if (is_plant(block_type)) {
draw_plant(
item_position_buffer, item_normal_buffer, item_uv_buffer,
position_loc, normal_loc, uv_loc);
}
else {
draw_cube(
item_position_buffer, item_normal_buffer, item_uv_buffer,
position_loc, normal_loc, uv_loc);
}
// swap buffers
glfwSwapBuffers(window);
glfwPollEvents();
}
client_stop();
db_save_state(x, y, z, rx, ry);
db_close();
glfwTerminate();
return 0;
}
static void krping_cq_event_handler(struct ib_cq *cq, void *ctx)
{
struct krping_cb *cb = ctx;
struct ib_wc wc;
struct ib_recv_wr *bad_wr;
int ret;
mtx_lock(&cb->lock);
KASSERT(cb->cq == cq, ("bad condition"));
if (cb->state == ERROR) {
log(LOG_ERR, "cq completion in ERROR state\n");
mtx_unlock(&cb->lock);
return;
}
if (!cb->wlat && !cb->rlat && !cb->bw)
ib_req_notify_cq(cb->cq, IB_CQ_NEXT_COMP);
while ((ret = ib_poll_cq(cb->cq, 1, &wc)) == 1) {
if (wc.status) {
if (wc.status == IB_WC_WR_FLUSH_ERR) {
DEBUG_LOG("cq flushed\n");
continue;
} else {
log(LOG_CRIT, "cq completion failed status %d\n",
wc.status);
goto error;
}
}
switch (wc.opcode) {
case IB_WC_SEND:
DEBUG_LOG(PFX "send completion\n");
cb->stats.send_bytes += cb->send_sgl.length;
cb->stats.send_msgs++;
break;
case IB_WC_RDMA_WRITE:
DEBUG_LOG(PFX "rdma write completion\n");
cb->stats.write_bytes += cb->rdma_sq_wr.sg_list->length;
cb->stats.write_msgs++;
cb->state = RDMA_WRITE_COMPLETE;
wakeup(cb);
break;
case IB_WC_RDMA_READ:
DEBUG_LOG(PFX "rdma read completion\n");
cb->stats.read_bytes += cb->rdma_sq_wr.sg_list->length;
cb->stats.read_msgs++;
cb->state = RDMA_READ_COMPLETE;
wakeup(cb);
break;
case IB_WC_RECV:
DEBUG_LOG(PFX "recv completion\n");
cb->stats.recv_bytes += sizeof(cb->recv_buf);
cb->stats.recv_msgs++;
if (cb->wlat || cb->rlat || cb->bw)
ret = server_recv(cb, &wc);
else
ret = cb->server ? server_recv(cb, &wc) :
client_recv(cb, &wc);
if (ret) {
log(LOG_ERR, "recv wc error: %d\n", ret);
goto error;
}
ret = ib_post_recv(cb->qp, &cb->rq_wr, &bad_wr);
if (ret) {
log(LOG_ERR, "post recv error: %d\n",
ret);
goto error;
}
wakeup(cb);
break;
default:
log(LOG_ERR, "unknown!!!!! completion\n");
goto error;
}
}
if (ret) {
log(LOG_ERR, "poll error %d\n", ret);
goto error;
}
mtx_unlock(&cb->lock);
return;
error:
cb->state = ERROR;
wakeup(cb);
mtx_unlock(&cb->lock);
}
/** Read a 'packet' of data from a connection and process it. Read in
* 8k chunks to give a better performance rating (for server
* connections). Do some tricky stuff for client connections to make
* sure they don't do any flooding >:-) -avalon
* @param cptr Client from which to read data.
* @param socket_ready If non-zero, more data can be read from the client's socket.
* @return Positive number on success, zero on connection-fatal failure, negative
* if user is killed.
*/
static int read_packet(struct Client *cptr, int socket_ready)
{
unsigned int dolen = 0;
unsigned int length = 0;
if (socket_ready &&
!(IsUser(cptr) &&
DBufLength(&(cli_recvQ(cptr))) > feature_uint(FEAT_CLIENT_FLOOD))) {
#if defined(USE_SSL)
switch (client_recv(cptr, readbuf, sizeof(readbuf), &length)) {
#else
switch (os_recv_nonb(cli_fd(cptr), readbuf, sizeof(readbuf), &length)) {
#endif
case IO_SUCCESS:
if (length)
{
cli_lasttime(cptr) = CurrentTime;
ClearPingSent(cptr);
ClrFlag(cptr, FLAG_NONL);
if (cli_lasttime(cptr) > cli_since(cptr))
cli_since(cptr) = cli_lasttime(cptr);
}
break;
case IO_BLOCKED:
break;
case IO_FAILURE:
cli_error(cptr) = errno;
/* SetFlag(cptr, FLAG_DEADSOCKET); */
return 0;
}
}
/*
* For server connections, we process as many as we can without
* worrying about the time of day or anything :)
*/
if (length > 0 && IsServer(cptr))
return server_dopacket(cptr, readbuf, length);
else if (length > 0 && (IsHandshake(cptr) || IsConnecting(cptr)))
return connect_dopacket(cptr, readbuf, length);
else
{
/*
* Before we even think of parsing what we just read, stick
* it on the end of the receive queue and do it when its
* turn comes around.
*/
if (length > 0 && dbuf_put(cptr, &(cli_recvQ(cptr)), readbuf, length) == 0)
return exit_client(cptr, cptr, &me, "dbuf_put fail");
if ((DBufLength(&(cli_recvQ(cptr))) > feature_uint(FEAT_CLIENT_FLOOD))
&& !IsChannelService(cptr))
return exit_client(cptr, cptr, &me, "Excess Flood");
while (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) &&
(IsTrusted(cptr) || IsChannelService(cptr) || cli_since(cptr) - CurrentTime < 10))
{
dolen = dbuf_getmsg(&(cli_recvQ(cptr)), cli_buffer(cptr), BUFSIZE);
/*
* Devious looking...whats it do ? well..if a client
* sends a *long* message without any CR or LF, then
* dbuf_getmsg fails and we pull it out using this
* loop which just gets the next 512 bytes and then
* deletes the rest of the buffer contents.
* -avalon
*/
if (dolen == 0)
{
if (DBufLength(&(cli_recvQ(cptr))) < 510)
SetFlag(cptr, FLAG_NONL);
else
{
/* More than 512 bytes in the line - drop the input and yell
* at the client.
*/
DBufClear(&(cli_recvQ(cptr)));
send_reply(cptr, ERR_INPUTTOOLONG);
}
}
else if (client_dopacket(cptr, dolen) == CPTR_KILLED)
return CPTR_KILLED;
/*
* If it has become registered as a Server
* then skip the per-message parsing below.
*/
if (IsHandshake(cptr) || IsServer(cptr))
{
while (-1)
{
dolen = dbuf_get(&(cli_recvQ(cptr)), readbuf, sizeof(readbuf));
if (dolen <= 0)
return 1;
else if (dolen == 0)
{
if (DBufLength(&(cli_recvQ(cptr))) < 510)
SetFlag(cptr, FLAG_NONL);
else {
DBufClear(&(cli_recvQ(cptr)));
/* send_reply(cptr, ERR_INPUTTOOLONG); */
}
}
else if ((IsServer(cptr) &&
server_dopacket(cptr, readbuf, dolen) == CPTR_KILLED) ||
(!IsServer(cptr) &&
connect_dopacket(cptr, readbuf, dolen) == CPTR_KILLED))
return CPTR_KILLED;
}
}
}
/* If there's still data to process, wait 2 seconds first */
if (DBufLength(&(cli_recvQ(cptr))) && !NoNewLine(cptr) &&
!t_onqueue(&(cli_proc(cptr))))
{
Debug((DEBUG_LIST, "Adding client process timer for %C", cptr));
cli_freeflag(cptr) |= FREEFLAG_TIMER;
timer_add(&(cli_proc(cptr)), client_timer_callback, cli_connect(cptr),
TT_RELATIVE, 2);
}
}
return 1;
}
/** Start a connection to another server.
* @param aconf Connect block data for target server.
* @param by Client who requested the connection (if any).
* @return Non-zero on success; zero on failure.
*/
int connect_server(struct ConfItem* aconf, struct Client* by)
{
struct Client* cptr = 0;
assert(0 != aconf);
if (aconf->dns_pending) {
sendto_opmask(0, SNO_OLDSNO, "Server %s connect DNS pending",
aconf->name);
return 0;
}
Debug((DEBUG_NOTICE, "Connect to %s[@%s]", aconf->name,
ircd_ntoa(&aconf->address.addr)));
if ((cptr = FindClient(aconf->name))) {
if (IsServer(cptr) || IsMe(cptr)) {
sendto_opmask(0, SNO_OLDSNO, "Server %s already present from %s",
aconf->name, cli_name(cli_from(cptr)));
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Server %s already present "
"from %s", by, aconf->name, cli_name(cli_from(cptr)));
}
return 0;
}
else if (IsHandshake(cptr) || IsConnecting(cptr)) {
if (by && IsUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connection to %s already in "
"progress", by, cli_name(cptr));
}
return 0;
}
}
/*
* If we don't know the IP# for this host and it is a hostname and
* not a ip# string, then try and find the appropriate host record.
*/
if (!irc_in_addr_valid(&aconf->address.addr)
&& !ircd_aton(&aconf->address.addr, aconf->host)) {
char buf[HOSTLEN + 1];
host_from_uh(buf, aconf->host, HOSTLEN);
gethost_byname(buf, connect_dns_callback, aconf);
aconf->dns_pending = 1;
return 0;
}
cptr = make_client(NULL, STAT_UNKNOWN_SERVER);
/*
* Copy these in so we have something for error detection.
*/
ircd_strncpy(cli_name(cptr), aconf->name, HOSTLEN);
ircd_strncpy(cli_sockhost(cptr), aconf->host, HOSTLEN);
/*
* Attach config entries to client here rather than in
* completed_connection. This to avoid null pointer references
*/
attach_confs_byhost(cptr, aconf->host, CONF_SERVER);
if (!find_conf_byhost(cli_confs(cptr), aconf->host, CONF_SERVER)) {
sendto_opmask(0, SNO_OLDSNO, "Host %s is not enabled for "
"connecting: no Connect block", aconf->name);
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Connect to host %s failed: no "
"Connect block", by, aconf->name);
}
det_confs_butmask(cptr, 0);
free_client(cptr);
return 0;
}
/*
* attempt to connect to the server in the conf line
*/
if (!connect_inet(aconf, cptr)) {
if (by && IsUser(by) && !MyUser(by)) {
sendcmdto_one(&me, CMD_NOTICE, by, "%C :Couldn't connect to %s", by,
cli_name(cptr));
}
det_confs_butmask(cptr, 0);
free_client(cptr);
return 0;
}
/*
* NOTE: if we're here we have a valid C:Line and the client should
* have started the connection and stored the remote address/port and
* ip address name in itself
*
* The socket has been connected or connect is in progress.
*/
make_server(cptr);
if (by && IsUser(by)) {
ircd_snprintf(0, cli_serv(cptr)->by, sizeof(cli_serv(cptr)->by), "%s%s",
NumNick(by));
assert(0 == cli_serv(cptr)->user);
cli_serv(cptr)->user = cli_user(by);
cli_user(by)->refcnt++;
}
else {
*(cli_serv(cptr))->by = '\0';
/* strcpy(cptr->serv->by, "Auto"); */
}
cli_serv(cptr)->up = &me;
SetConnecting(cptr);
if (cli_fd(cptr) > HighestFd)
HighestFd = cli_fd(cptr);
LocalClientArray[cli_fd(cptr)] = cptr;
Count_newunknown(UserStats);
/* Actually we lie, the connect hasn't succeeded yet, but we have a valid
* cptr, so we register it now.
* Maybe these two calls should be merged.
*/
add_client_to_list(cptr);
hAddClient(cptr);
/* nextping = CurrentTime; */
return (s_state(&cli_socket(cptr)) == SS_CONNECTED) ?
completed_connection(cptr) : 1;
}
/** Find the real hostname for the host running the server (or one which
* matches the server's name) and its primary IP#. Hostname is stored
* in the client structure passed as a pointer.
*/
void init_server_identity(void)
{
const struct LocalConf* conf = conf_get_local();
assert(0 != conf);
ircd_strncpy(cli_name(&me), conf->name, HOSTLEN);
SetYXXServerName(&me, conf->numeric);
}
/** Process events on a client socket.
* @param ev Socket event structure that has a struct Connection as
* its associated data.
*/
static void client_sock_callback(struct Event* ev)
{
struct Client* cptr;
struct Connection* con;
char *fmt = "%s";
char *fallback = 0;
assert(0 != ev_socket(ev));
assert(0 != s_data(ev_socket(ev)));
con = (struct Connection*) s_data(ev_socket(ev));
assert(0 != con_client(con) || ev_type(ev) == ET_DESTROY);
cptr = con_client(con);
assert(0 == cptr || con == cli_connect(cptr));
switch (ev_type(ev)) {
case ET_DESTROY:
con_freeflag(con) &= ~FREEFLAG_SOCKET;
if (!con_freeflag(con) && !cptr)
free_connection(con);
#if defined(USE_SSL)
ssl_free(ev_socket(ev));
#endif
break;
case ET_CONNECT: /* socket connection completed */
if (!completed_connection(cptr) || IsDead(cptr))
fallback = cli_info(cptr);
break;
case ET_ERROR: /* an error occurred */
fallback = cli_info(cptr);
cli_error(cptr) = ev_data(ev);
/* If the OS told us we have a bad file descriptor, we should
* record that for future reference.
*/
if (cli_error(cptr) == EBADF)
cli_fd(cptr) = -1;
if (s_state(&(con_socket(con))) == SS_CONNECTING) {
completed_connection(cptr);
/* for some reason, the os_get_sockerr() in completed_connection()
* can return 0 even when ev_data(ev) indicates a real error, so
* re-assign the client error here.
*/
cli_error(cptr) = ev_data(ev);
break;
}
/*FALLTHROUGH*/
case ET_EOF: /* end of file on socket */
Debug((DEBUG_ERROR, "READ ERROR: fd = %d %d", cli_fd(cptr),
cli_error(cptr)));
SetFlag(cptr, FLAG_DEADSOCKET);
if ((IsServer(cptr) || IsHandshake(cptr)) && cli_error(cptr) == 0) {
exit_client_msg(cptr, cptr, &me, "Server %s closed the connection (%s)",
cli_name(cptr), cli_serv(cptr)->last_error_msg);
return;
} else {
fmt = "Read error: %s";
fallback = "EOF from client";
}
break;
case ET_WRITE: /* socket is writable */
ClrFlag(cptr, FLAG_BLOCKED);
if (cli_listing(cptr) && MsgQLength(&(cli_sendQ(cptr))) < 2048)
list_next_channels(cptr);
Debug((DEBUG_SEND, "Sending queued data to %C", cptr));
send_queued(cptr);
break;
case ET_READ: /* socket is readable */
if (!IsDead(cptr)) {
Debug((DEBUG_DEBUG, "Reading data from %C", cptr));
if (read_packet(cptr, 1) == 0) /* error while reading packet */
fallback = "EOF from client";
}
break;
default:
assert(0 && "Unrecognized socket event in client_sock_callback()");
break;
}
assert(0 == cptr || 0 == cli_connect(cptr) || con == cli_connect(cptr));
if (fallback) {
const char* msg = (cli_error(cptr)) ? strerror(cli_error(cptr)) : fallback;
if (!msg)
msg = "Unknown error";
exit_client_msg(cptr, cptr, &me, fmt, msg);
}
}
/** Process a timer on client socket.
* @param ev Timer event that has a struct Connection as its
* associated data.
*/
static void client_timer_callback(struct Event* ev)
{
struct Client* cptr;
struct Connection* con;
assert(0 != ev_timer(ev));
assert(0 != t_data(ev_timer(ev)));
assert(ET_DESTROY == ev_type(ev) || ET_EXPIRE == ev_type(ev));
con = (struct Connection*) t_data(ev_timer(ev));
assert(0 != con_client(con) || ev_type(ev) == ET_DESTROY);
cptr = con_client(con);
assert(0 == cptr || con == cli_connect(cptr));
if (ev_type(ev)== ET_DESTROY) {
con_freeflag(con) &= ~FREEFLAG_TIMER; /* timer has expired... */
if (!con_freeflag(con) && !cptr)
free_connection(con); /* client is being destroyed */
} else {
Debug((DEBUG_LIST, "Client process timer for %C expired; processing",
cptr));
read_packet(cptr, 0); /* read_packet will re-add timer if needed */
}
assert(0 == cptr || 0 == cli_connect(cptr) || con == cli_connect(cptr));
}
/******************************************************************
* This function is called when an event occurs on a client socket
******************************************************************/
void client_cb(int fd, short events, void *arg)
{
assert(arg != NULL);
Client *cli = arg;
int free = 0;
// g_hash_table_foreach(g_jobqueue, _print_queue, NULL);
if ((events & EV_WRITE) != 0) {
event_del(&cli->evt);
cli->evt.ev_events = EV_READ|EV_PERSIST;
event_add(&cli->evt, NULL);
if (client_flush(cli) < 0) {
free = 1;
}
}
if ((events & EV_READ) != 0) {
int ret = 0;
if (!cli->buffer_in) {
cli->buffer_in = getBlock(HEADER_SIZE);
incRef(cli->buffer_in);
ret = client_recv(cli, HEADER_SIZE);
}
if (ret >= 0) {
/* Make sure we don't over-read into the next packet */
int psize = HEADER_SIZE;
if (cli->buffer_in->nbytes >= HEADER_SIZE) {
if (ntohl(*(uint32_t*)(cli->buffer_in->bytes + HEADER_OFFSET_MAGIC)) != MAGIC_REQUEST) {
free = 1;
g_warning("[%s] Invalid MAGIC", cli->id);
goto free_client;
}
psize = HEADER_SIZE + ntohl(*(uint32_t*)(cli->buffer_in->bytes + HEADER_OFFSET_SIZE));
/* If the input block isn't large enough to receive the
entire packet then switch to one that is */
if (psize > cli->buffer_in->size) {
#if DEBUG
g_debug("Switching to bigger block (pktsize=%d)", psize);
#endif
/* Create new (bigger) block */
MemBlock *block = getBlock(psize + 1); /* +1 for terminating NULL to make args easier to work with */
if (!block) {
g_error("Failed to get block of size %d", psize);
free = 1;
goto free_client;
}
incRef(block);
/* Copy bytes into new block */
block->nbytes = cli->buffer_in->nbytes;
memmove(block->bytes, cli->buffer_in->bytes, cli->buffer_in->nbytes);
/* Swap blocks */
decRef(cli->buffer_in);
cli->buffer_in = block;
}
}
int num = psize - cli->buffer_in->nbytes;
if (num > 0)
ret = client_recv(cli, num);
}
if (ret < 0) {
#if DEBUG
g_debug("[%s] Connection on closed", cli->id);
#endif
free = 1;
} else if (ret >= 0) {
if (process_client(cli) != 0) {
g_warning("[%s] Processing of client failed", cli->id);
free = 1;
}
}
}
/*if ((events & (EV_READ|EV_WRITE)) == 0) {
g_warning("[%s] unhandled event %d", __func__, events);
}*/
free_client:
if (free != 0) {
#if DEBUG
g_message("[%s] Client disconnected", cli->id);
#endif
/*printf("[%s] Removing client %d\n", __func__, cli->fd);*/
close(cli->fd);
cli->fd = -1;
fail_working_jobs(cli);
stop_all_listening(cli);
unregister_all_abilities(cli);
event_del(&cli->evt);
g_ptr_array_remove_fast(g_clients, cli);
client_free(cli);
}
}
/*
* otras funciones
*/
TEG_STATUS pre_client_recv( gpointer data, int sock, GdkInputCondition GDK_INPUT_READ )
{
client_recv( sock );
return TEG_STATUS_SUCCESS;
}
/* connects and registers with the router */
int main( int argc, char** argv ) {
if( argc < 5 ) {
osrfLogError( OSRF_LOG_MARK, "Usage: %s <username> <host> <resource> <recipient> \n", argv[0] );
return 99;
}
transport_message* send;
transport_client* client = client_init( argv[2], 5222, 0 );
// try to connect, allow 15 second connect timeout
if( client_connect( client, argv[1], "jkjkasdf", argv[3], 15, AUTH_DIGEST ) )
osrfLogInfo(OSRF_LOG_MARK, "Connected...\n");
else {
osrfLogError( OSRF_LOG_MARK, "NOT Connected...\n" );
return -1;
}
if( (pid=fork()) ) { /* parent */
signal(SIGINT, sig_int);
fprintf(stderr, "Listener: %ld\n", (long) getpid() );
char buf[300];
osrf_clearbuf(buf, sizeof(buf));
printf("=> ");
while( fgets( buf, sizeof(buf), stdin) ) {
// remove newline
buf[strlen(buf)-1] = '\0';
if( strcmp(buf, "exit")==0) {
client_free( client );
break;
}
send = message_init( buf, "", "123454321", argv[4], NULL );
client_send_message( client, send );
message_free( send );
printf("\n=> ");
osrf_clearbuf(buf, sizeof(buf));
}
fprintf(stderr, "Killing child %d\n", pid );
kill( pid, SIGKILL );
return 0;
} else {
fprintf(stderr, "Sender: %ld\n", (long) getpid() );
transport_message* recv;
while( (recv=client_recv( client, -1)) ) {
if( recv->is_error )
fprintf( stderr, "\nReceived Error\t: ------------------\nFrom:\t\t"
"%s\nRouterFrom:\t%s\nBody:\t\t%s\nType %s\nCode %d\n=> ",
recv->sender, recv->router_from, recv->body, recv->error_type, recv->error_code );
else
fprintf( stderr, "\nReceived\t: ------------------\nFrom:\t\t"
"%s\nRouterFrom:\t%s\nBody:\t\t%s\n=> ", recv->sender, recv->router_from, recv->body );
message_free( recv );
}
}
return 0;
}
int run_client(uint16_t port, vpn_conf_t *my)
{
fd_set fds;
int r, fd = 0, ppp = 0;
struct in_addr out;
struct sockaddr_in s;
char temp[VPN_PACKET];
if(vpn_cryptinit(&cry, my->algo, my->srckey, my->dstkey) == -1)
return -1;
signal(SIGHUP, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
if((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
xmsg(0, VPN_DEBUG|VPN_INFO, "socket: %s\n", errstr);
vpn_cryptfinish(&cry);
exit(1);
}
if(!inet_aton(my->dstaddr, &out)) {
xmsg(0, VPN_DEBUG|VPN_INFO, "invalid IP address: %s\n", my->dstaddr);
vpn_cryptfinish(&cry);
exit(1);
}
/* connect */
s.sin_family = AF_INET;
s.sin_port = port;
s.sin_addr = out;
if(connect(fd, (struct sockaddr *)&s, sizeof(s)) == -1) {
close(fd);
vpn_cryptfinish(&cry);
return xmsg(-1, VPN_DEBUG|VPN_INFO,
"connect (%s): %s\n", my->name, errstr);
}
/* set O_NONBLOCK, KEEPALIVE and TCP_NODELAY */
sockattr(fd);
/* send VPN name */
memset(temp, 0, sizeof(temp));
snprintf(temp, sizeof(temp), "%s\n", my->name);
send(fd, temp, strlen(temp), 0);
/* xmsg(0, VPN_TERM, "connected to %s, running pppd\n", my->name); */
/* run pppd */
if((ppp = run_pppd(my->ppplocal, my->pppremote, &pppd_pid)) == -1) {
close(fd);
vpn_cryptfinish(&cry);
return xmsg(-1, VPN_DEBUG|VPN_INFO, "unable to start pppd\n");
} else
xmsg(0, VPN_INFO, "connected to %s\n", my->name);
/* save pidfile */
save_pidfile(my->name);
/* set signals */
signal(SIGINT, mysig);
signal(SIGTERM, mysig);
signal(SIGKILL, mysig);
signal(SIGSEGV, mysig);
for(;;) {
FD_ZERO(&fds);
FD_SET(fd, &fds);
FD_SET(ppp, &fds);
if(select(ppp+1, &fds, 0, 0, 0) >= 1) {
memset(temp, 0, sizeof(temp));
if(FD_ISSET(fd, &fds)) {
if((r = client_recv(fd, &cry, temp, sizeof(temp))) >= 1)
write(ppp, temp, r);
else {
/* received invalid packet or peer disconnected
* kill pppd */
kill(pppd_pid, SIGTERM);
break;
}
} else
if(FD_ISSET(ppp, &fds)) {
r = read(ppp, temp, sizeof(temp));
if(r == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
continue;
else
if(r <= 0) {
xmsg(0, VPN_DEBUG|VPN_INFO, "lost pppd connection\n");
break;
}
client_send(fd, &cry, temp, r);
}
} else
break;
/* run `up' command */
if(!ifup) {
if(!run_cmd(my->cmdup, my->ppplocal)) {
my_ptr = my;
ifup = 1;
}
}
}
if(fd) close(fd);
if(ppp) close(ppp);
vpn_cryptfinish(&cry);
/* run downcmd */
if(ifup) {
run_cmd(my->cmddown, NULL);
ifup = 0;
}
return 0;
}