void tcp_reverse_proxy(int server_port, const char* printer, int printer_port)
{
int servfd, clifd;
struct sockaddr_in servaddr, cliaddr;
servfd = tcp_create_socket();
tcp_bind_and_listen(servfd, server_port);
while (1) {
long timestamp;
socklen_t length = sizeof(cliaddr);
clifd = accept(servfd, (struct sockaddr*)&cliaddr, &length);
if (clifd < 0) {
printf("error comes when call accept!\n");
break;
}
pthread_t id = 0;
tcp_server_thread_info* pinfo = new tcp_server_thread_info();
bzero(pinfo, sizeof(tcp_server_thread_info));
strcpy(pinfo->printer, printer);
pinfo->printer_port = printer_port;
pinfo->accepted_socket = clifd;
int ret = pthread_create(&id, NULL, tcp_server_handler, pinfo);
if (ret != 0) {
printf ("Create pthread error!\n");
exit (1);
}
}
}
int tcp_connect_to_stamp(const char* stamp, int port)
{
int stamp_socket = tcp_create_socket(port);
struct addrinfo hints, *res;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
// hints.ai_flags |= AI_CANONNAME;
char tmp[6]; // max is 65535
sprintf(tmp,"%5d",port);
getaddrinfo(stamp, tmp, &hints, &res);
if (connect(stamp_socket,res->ai_addr, res->ai_addrlen) < 0)
{
DEBUG("cannot connect\n");
exit(1);
}
freeaddrinfo(res);
return stamp_socket;
}
/*
Sets up the object.
- ...
*/
RC_TYPE tcp_do_initialize(TCP_SOCKET *p_self,int is_connect_all)
{
RC_TYPE rc;
int i=0;
do
{
if (!(RC_OK==(rc=tcp_create_socket(p_self))))
break;
rc=RC_IP_CONNECT_FAILED;
for (i=0;i<p_self->super.server_socket_count;i++) {
/*connect*/
if (0 == connect(p_self->super.socket[i],p_self->super.addr_ar[i]->ai_addr,
p_self->super.addr_ar[i]->ai_addrlen)) {
rc=RC_OK;
if (is_connect_all) {
p_self->super.sock_index=0;
}
else {
p_self->super.sock_index=i;
break;
}
}
}
}
while(0);
if (rc != RC_OK)
{
tcp_shutdown(p_self);
}
else
{
p_self->initialized = TRUE;
}
return rc;
}
int tcp_connect_to_printer(const char* printer, int port)
{
int printer_socket = tcp_create_socket();
hostent* printer_host = gethostbyname(printer);
sockaddr_in printer_addr;
bzero((char *)&printer_addr, sizeof(sockaddr_in));
printer_addr.sin_family = AF_INET;
bcopy((char *)printer_host->h_addr, (char *)&printer_addr.sin_addr.s_addr, printer_host->h_length);
printer_addr.sin_port = htons(port);
if (connect(printer_socket, (sockaddr *)&printer_addr, sizeof(printer_addr)) < 0) {
printf("cannot connect to printer\n");
exit(1);
}
return printer_socket;
}
void tcp_reverse_proxy(int server_port, const char* stamp, int stamp_port, int waf_mode, char *logname)
{
int servfd, clifd;
struct sockaddr_in cliaddr;
servfd = tcp_create_socket(server_port);
tcp_bind_and_listen(servfd, server_port);
while (1)
{
socklen_t length = sizeof(cliaddr);
clifd = accept(servfd, (struct sockaddr*)&cliaddr, &length);
if (clifd < 0)
{
DEBUG("Error when call accept()\n");
break;
}
pthread_t id = 0;
struct tcp_server_thread_info *pinfo =(struct tcp_server_thread_info *) xmalloc(sizeof(struct tcp_server_thread_info));
bzero(pinfo, sizeof(struct tcp_server_thread_info));
strcpy(pinfo->stamp, stamp);
pinfo->stamp_port = stamp_port;
pinfo->accepted_socket = clifd;
strcpy(pinfo->log_reg,logname);
pinfo->wafmode = waf_mode;
int ret = pthread_create(&id, NULL, tcp_server_handler, pinfo);
if (ret != 0)
{
DEBUG("Create pthread error!\n");
exit (1);
}
// tcp_server_handler() use free() at pinfo pointer, if call free() here causes double free
}
}
/*
* Create TCP socket and connect to ip:port.
*
* Return connected socket.
*/
static int setup_forward_tcp(int port, char *ip)
{
int ret, sock;
sock = tcp_create_socket();
if (sock < 0) {
goto error;
}
ret = tcp_connect_socket(sock, port, ip);
if (ret < 0) {
ERR("Unable to connect to TCP tunnel");
fprintf(stderr,
"Recommended to use ssh -L %s:%d:%s:53 HOST for tunneling\n",
ip, port, dns_ip);
goto error;
}
return sock;
error:
return -1;
}
static CvsServerCtx * open_ctx_pserver(CvsServerCtx * ctx, const char * p_root)
{
char root[PATH_MAX];
char full_root[PATH_MAX];
char * p = root, *tok, *tok2;
char user[BUFSIZ];
char server[BUFSIZ];
char pass[BUFSIZ];
char port[8];
strcpy_a(root, p_root, PATH_MAX);
tok = strsep(&p, ":");
if (strlen(tok) == 0 || !p)
{
debug(DEBUG_APPERROR, "parse error on third token");
goto out_free_err;
}
tok2 = strsep(&tok, "@");
if (!strlen(tok2) || (!tok || !strlen(tok)))
{
debug(DEBUG_APPERROR, "parse error on user@server in pserver");
goto out_free_err;
}
strcpy_a(user, tok2, BUFSIZ);
strcpy_a(server, tok, BUFSIZ);
if (*p != '/')
{
tok = strchr(p, '/');
if (!tok)
{
debug(DEBUG_APPERROR, "parse error: expecting / in root");
goto out_free_err;
}
memset(port, 0, sizeof(port));
memcpy(port, p, tok - p);
p = tok;
}
else
{
strcpy_a(port, "2401", 8);
}
/* the line from .cvspass is fully qualified, so rebuild */
snprintf(full_root, PATH_MAX, ":pserver:%s@%s:%s%s", user, server, port, p);
get_cvspass(pass, full_root, BUFSIZ);
debug(DEBUG_TCP, "user:%s server:%s port:%s pass:%s full_root:%s", user, server, port, pass, full_root);
if ((ctx->read_fd = tcp_create_socket(REUSE_ADDR)) < 0)
goto out_free_err;
ctx->write_fd = dup(ctx->read_fd);
if (tcp_connect(ctx->read_fd, server, atoi(port)) < 0)
goto out_close_err;
send_string(ctx, "BEGIN AUTH REQUEST\n");
send_string(ctx, "%s\n", p);
send_string(ctx, "%s\n", user);
send_string(ctx, "%s\n", pass);
send_string(ctx, "END AUTH REQUEST\n");
if (!read_response(ctx, "I LOVE YOU"))
goto out_close_err;
strcpy_a(ctx->root, p, PATH_MAX);
ctx->is_pserver = 1;
return ctx;
out_close_err:
close(ctx->read_fd);
out_free_err:
free(ctx);
return NULL;
}
int main(int argc, char **argv)
{
fd_set socklist;
int status;
int ssl_sock, tcp_sock, max_sock;
int select_ret;
int uid;
struct timeval tv;
SSL_CTX *ctx;
if (argc < 2) {
printf("Usage: %s master/slave\n", argv[0]);
exit(0);
}
if (!strcmp(argv[1], "master")) {
global_type = MASTER;
} else {
global_type = SLAVE;
}
uid = getuid();
if (uid != 0) {
fprintf(stderr, "Not root user\n");
exit(6);
}
if(system("/usr/local/lxlabs/ext/php/php ../bin/sisinfoc.php") != EXIT_SUCCESS)
{
fprintf(stderr, "Could not execute sisinfoc.php\n");
exit(EXIT_FAILURE);
}
if(system("/usr/local/lxlabs/ext/php/php ../bin/execatstart.php") != EXIT_SUCCESS)
{
fprintf(stderr, "Could not execute sisinfoc.php\n");
exit(EXIT_FAILURE);
}
ctx = ssl_init();
if (!strcmp(argv[0], "../sbin/hypervm.exe")) {
ssl_sock = tcp_create_socket(8889);
tcp_sock = tcp_create_socket(8886);
} else {
ssl_sock = tcp_create_socket(7779);
tcp_sock = tcp_create_socket(7776);
}
while (1) {
tv.tv_sec = 3;
tv.tv_sec = 60;
tv.tv_usec = 0;
FD_ZERO(&socklist); /* Always clear the structure first. */
FD_SET(ssl_sock, &socklist);
FD_SET(tcp_sock, &socklist);
max_sock = (tcp_sock > ssl_sock? tcp_sock : ssl_sock);
max_sock += 1;
select_ret = select(max_sock, &socklist, NULL, NULL, &tv);
if (select_ret == -1) {
perror("Select");
exit(0);
}
while (wait3(&status, WNOHANG, 0) > 0);
process_timed_in_child();
if (select_ret > 0) {
if (FD_ISSET(tcp_sock, &socklist)) {
/* printf("TCP connection %d\n", select_ret); */
ssl_or_tcp_fork(tcp_sock, NULL);
}
if (FD_ISSET(ssl_sock, &socklist)) {
/* printf("SSl connection %d\n", select_ret); */
ssl_or_tcp_fork(ssl_sock, ctx);
}
}
}
}
int main(int argc, char **argv)
{
int err;
int pid;
int sock;
fd_set socklist;
int status;
int ssl_sock, tcp_sock, max_sock;
int select_ret;
struct timeval tv;
SSL_CTX *ctx;
// disable stdout buffering
setvbuf(stdout, NULL, _IONBF, 0);
if (argc < 2) {
printf("Usage: %s master|slave\n", argv[0]);
exit(0);
}
if (!strcmp(argv[1], "master")) {
global_type = MASTER;
} else {
global_type = SLAVE;
}
if (getuid() != 0) {
printf("Not root user\n");
exit(6);
}
exec_sisinfoc();
ctx = ssl_init();
ssl_sock = tcp_create_socket(7779);
tcp_sock = tcp_create_socket(7776);
while (1) {
tv.tv_sec = 60;
tv.tv_usec = 0;
FD_ZERO(&socklist); /* Always clear the structure first. */
FD_SET(ssl_sock, &socklist);
FD_SET(tcp_sock, &socklist);
max_sock = (tcp_sock > ssl_sock ? tcp_sock : ssl_sock);
max_sock += 1;
select_ret = select(max_sock, &socklist, NULL, NULL, &tv);
if (select_ret == -1) {
perror("Select");
exit(0);
}
while (wait3(&status, WNOHANG, 0) > 0);
check_restart();
exec_sisinfoc();
exec_scavenge();
if (select_ret > 0) {
if (FD_ISSET(tcp_sock, &socklist)) {
//printf("TCP connection %d\n", select_ret);
ssl_or_tcp_fork(tcp_sock, NULL);
}
if (FD_ISSET(ssl_sock, &socklist)) {
//printf("SSl connection %d\n", select_ret);
ssl_or_tcp_fork(ssl_sock, ctx);
}
}
}
}
