Example #1
0
void
source_accept_cb(uv_stream_t *server, int status) {
    struct source_context *source = new_source();
    struct target_context *target = new_target();

    source->target = target;
    target->source = source;

    uv_tcp_init(server->loop, &source->handle.tcp);
    uv_tcp_init(server->loop, &target->handle.tcp);

    uv_tcp_nodelay(&source->handle.tcp, 0);
    uv_tcp_nodelay(&target->handle.tcp, 0);
    uv_tcp_keepalive(&source->handle.tcp, 1, 60);
    uv_tcp_keepalive(&target->handle.tcp, 1, 60);

    int rc = uv_accept(server, &source->handle.stream);
    if (rc == 0) {
        connect_to_target(target);
    } else {
        logger_log(LOG_ERR, "accept error: %s", uv_strerror(rc));
        close_source(source);
        close_target(target);
    }
}
Example #2
0
static void
source_recv_cb(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
    struct source_context *source = stream->data;
    struct target_context *target = source->target;

    if (nread > 0) {
        if (mode == TUNNEL_MODE_CLIENT) {
            int clen = nread + PRIMITIVE_BYTES;
            uint8_t *c = source->packet.buf + HEADER_BYTES;
            int rc = crypto_encrypt(c, (uint8_t*)buf->base, nread);
            if (rc) {
                goto error;
            }
            forward_to_target(target, c, clen);

        } else {
            struct packet *packet = &source->packet;
            int rc = packet_filter(packet, buf->base, nread);
            if (rc == PACKET_COMPLETED) {
                uint8_t *m = packet->buf;
                int mlen = packet->size - PRIMITIVE_BYTES;

                int err = crypto_decrypt(m, packet->buf, packet->size);
                if (err) {
                    goto error;
                }

                forward_to_target(target, m, mlen);

            } else if (rc == PACKET_INVALID) {
                goto error;
            }
        }

    } else if (nread < 0){
        close_source(source);
        close_target(target);
    }

    return;

error:
    logger_log(LOG_ERR, "invalid packet");
    close_source(source);
    close_target(target);
}
Example #3
0
// render target
static RID
create_rt(struct render *R, RID texid) {
	struct target *tar = (struct target *)array_alloc(&R->target);
	if (tar == NULL)
		return 0;
	tar->tex = texid;
	struct texture * tex = (struct texture *)array_ref(&R->texture, texid);
	if (tex == NULL)
		return 0;
	glGenFramebuffers(1, &tar->glid);
	glBindFramebuffer(GL_FRAMEBUFFER, tar->glid);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex->glid, 0);
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
		close_target(tar, R);
		return 0;
	}
	CHECK_GL_ERROR

	return array_id(&R->target, tar);
}
Example #4
0
void 
render_release(struct render *R, enum RENDER_OBJ what, RID id) {
	switch (what) {
	case VERTEXBUFFER:
	case INDEXBUFFER: {
		struct buffer * buf = (struct buffer *)array_ref(&R->buffer, id);
		if (buf) {
			close_buffer(buf, R);
			array_free(&R->buffer, buf);
		}
		break;
	}
	case SHADER: {
		struct shader * shader = (struct shader *)array_ref(&R->shader, id);
		if (shader) {
			close_shader(shader, R);
			array_free(&R->shader, shader);
		}
		break;
	}
	case TEXTURE : {
		struct texture * tex = (struct texture *) array_ref(&R->texture, id);
		if (tex) {
			close_texture(tex, R);
			array_free(&R->texture, tex);
		}
		break;
	}
	case TARGET : {
		struct target * tar = (struct target *)array_ref(&R->target, id);
		if (tar) {
			close_target(tar, R);
			array_free(&R->target, tar);
		}
		break;
	}
	default:
		assert(0);
		break;
	}
}