void* connection_thread(void* arg) {
int sd;
gnutls_session_t session;
pp_session_t ppsession;
int ret;
sd = (int)(long)arg;
ret = initialize_tls_session(&session);
if (ret != GNUTLS_E_SUCCESS) {
fprintf(stderr, "Error initializing TLS session\n");
return (void *)(long)ret;
}
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t)(long)sd);
memset(&ppsession, '\0', sizeof(pp_session_t));
ppsession.cfg = &cfg;
gnutls_session_set_ptr(session, &ppsession);
ret = do_proxy(session);
if (ret != GNUTLS_E_SUCCESS)
fprintf(stderr, "- Proxy exited with failure\n");
close((int)(long)gnutls_transport_get_ptr(session));
gnutls_deinit(session);
return 0;
}
int main(int argc, char **argv)
{
int fd_frontend = socket_util_listen("0.0.0.0", PROXY_PORT);
while (1)
{
int fd_client = accept(fd_frontend, NULL, NULL);
int pid;
if ((pid = fork()) == -1)
return -1;
if (pid)
{
/* parent */
close(fd_client);
}
else
{
/* children */
close(fd_frontend);
do_proxy(fd_client);
errx(1, "should not gere here");
}
}
return 0;
}
/** proxy return replies to clients */
static void
service_proxy(fd_set* rset, int retsock, struct proxy* proxies,
sldns_buffer* pkt, struct timeval* now)
{
struct proxy* p;
for(p = proxies; p; p = p->next) {
if(FD_ISSET(p->s, rset)) {
p->lastuse = *now;
do_proxy(p, retsock, pkt);
}
}
}
int main(int argc, char *argv[]) {
int proxyfd, clifd;
struct sockaddr_in proxyaddr, cliaddr;
socklen_t cliaddrlen;
/* initialize the socket as a server */
proxyfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&proxyaddr, sizeof(proxyaddr));
proxyaddr.sin_family = AF_INET;
proxyaddr.sin_addr.s_addr = htonl(INADDR_ANY);
proxyaddr.sin_port = htons(PROXY_PORT);
Bind(proxyfd, (struct sockaddr *)&proxyaddr, sizeof(proxyaddr));
Listen(proxyfd, 5);
/* infinite loop waiting for and processing requests */
char cliaddrip[INET_ADDRSTRLEN];
int pid;
while (1) {
cliaddrlen = sizeof(cliaddr);
clifd = Accept(proxyfd, (struct sockaddr *)&cliaddr, &cliaddrlen);
Inet_ntop(AF_INET, &cliaddr.sin_addr, cliaddrip, INET_ADDRSTRLEN);
fprintf(stdout, "---Request comes, IP=%s\n", cliaddrip);
/* process the request in a subprocess */
if ((pid=fork()) == 0) {
pid = getpid();
fprintf(stdout, "---pid=%d, Process the request in a subprocess\n", pid);
fprintf(stdout, "---pid=%d, Close proxy socket in the subprocess\n", pid);
Close(proxyfd);
do_proxy(clifd, &cliaddr, pid);
fprintf(stdout, "---pid=%d, Close the client socket in the subprocess\n", pid);
Close(clifd);
fprintf(stdout, "---pid=%d, Subprocess exits\n", pid);
exit(0);
}
fprintf(stdout, "---Close the client socket in the parent process\n");
Close(clifd);
}
return 0;
}
int proxy(srs_flv_t flv, srs_rtmp_t ortmp) {
int ret = 0;
u_int32_t timestamp = 0;
int32_t starttime = -1;
char header[13];
if ((ret = srs_flv_read_header(flv, header)) != 0) {
return ret;
}
if ((ret = connect_oc(ortmp)) != 0) {
return ret;
}
int64_t re = re_create();
ret = do_proxy(flv, ortmp, re, &starttime, ×tamp);
// for the last pulse, always sleep.
re_cleanup(re, starttime, timestamp);
return ret;
}
public: optimal_solver_proxies proxy() const
{
return do_proxy();
}
int main(int argc, char *argv[])
{
int source_port;
char *destination_address;
int destination_port;
int server_sockfd = -1, client_sockfd = -1, target_sockfd = -1, admin_sockfd = -1, admin_client_sockfd = -1;
char *lock_filename;
/* Check parameters */
if(argc != 5)
{
print_usage();
_exit(1);
}
/* Get parameter values */
source_port = atoi(argv[1]);
destination_address = strdup(argv[2]);
destination_port = atoi(argv[3]);
lock_filename = strdup(argv[4]);
/* Create signal handlers */
signal(SIGINT, cleanup); /* Event handler for interruption */
signal(SIGCHLD, sigreap); /* Event handler when a child terminates */
/* Create server socket */
server_sockfd = create_server_socket(source_port);
set_nonblock(server_sockfd);
/* Create admin socket */
admin_sockfd = create_admin_socket("/tmp/disnix-tcp-proxy.sock");
set_nonblock(admin_sockfd);
/* Main loop */
while(TRUE)
{
int status;
/* Create admin client socket if there is an incoming connection */
if((admin_client_sockfd = wait_for_connection(admin_sockfd)) >= 0)
{
char msg[BUFFER_SIZE];
printf("Admin connection from client\n");
sprintf(msg, "%d", num_of_connections);
if(send(admin_client_sockfd, msg, strlen(msg), 0) < 0)
fprintf(stderr, "Error sending message to admin client: %s\n", strerror(errno));
close(admin_client_sockfd);
admin_client_sockfd = -1;
}
/* If we want to block do not accept any incoming client connections */
if(is_blocking(lock_filename))
continue;
/* Create client if there is an incoming connection */
if((client_sockfd = wait_for_connection(server_sockfd)) < 0)
continue;
/* Connect to the remote host */
if((target_sockfd = open_remote_host(destination_address, destination_port)) < 0)
{
close(client_sockfd);
client_sockfd = -1;
continue;
}
/* Fork a new process for each incoming client */
status = fork();
if(status == 0)
{
printf("Connection from client\n");
close(server_sockfd);
close(admin_sockfd);
do_proxy(client_sockfd, target_sockfd);
abort();
}
else if(status == -1)
fprintf(stderr, "Error in forking process\n");
else
num_of_connections++;
/* Close the connections to the remote host and client */
close(client_sockfd);
client_sockfd = -1;
close(target_sockfd);
target_sockfd = -1;
}
return 0;
}
void client_read(client *cl)
{
int status, pn;
status = mr_cont_receive(cl->con, &cl->req);
if (status == -1)
return;
else if (status != MR_SUCCESS)
{
cl->state = CL_CLOSING;
if (status != MR_NOT_CONNECTED)
com_err(whoami, status, "while reading from socket");
return;
}
pn = cl->req.u.mr_procno;
if (pn < 0 || pn > MR_MAX_PROC)
{
com_err(whoami, 0, "procno out of range");
client_reply(cl, MR_UNKNOWN_PROC);
goto out;
}
log_args(procnames[pn], 2, cl->req.mr_argc, cl->req.mr_argv);
if (dormant == ASLEEP && pn != MR_NOOP && pn != MR_MOTD)
{
client_reply(cl, MR_DOWN);
com_err(whoami, MR_DOWN, "(query refused)");
goto out;
}
/* make sure this gets cleared before every operation */
dbms_errno = 0;
switch (pn)
{
case MR_NOOP:
client_reply(cl, MR_SUCCESS);
break;
case MR_AUTH:
do_auth(cl);
break;
case MR_QUERY:
do_retr(cl);
break;
case MR_ACCESS:
do_access(cl);
break;
case MR_SHUTDOWN:
do_shutdown(cl);
break;
case MR_DO_UPDATE:
client_reply(cl, MR_PERM);
break;
case MR_MOTD:
get_motd(cl);
break;
case MR_PROXY:
do_proxy(cl);
break;
case MR_SETVERSION:
do_version(cl);
break;
case MR_KRB5_AUTH:
do_krb5_auth(cl);
break;
}
out:
mr_destroy_reply(cl->req);
memset(&cl->req, 0, sizeof(mr_params));
}
