/*********************************************************************************
|
* Copyright: (C) 2012 Guo Wenxue<guowenxue@gmail.com>
|
* All rights reserved.
|
*
|
* Filename: tpdud.c
|
* Description: This file
|
*
|
* Version: 1.0.0(10/30/2012~)
|
* Author: Guo Wenxue <guowenxue@gmail.com>
|
* ChangeLog: 1, Release initial version on "10/30/2012 01:15:18 PM"
|
*
|
********************************************************************************/
|
|
#include <unistd.h>
|
#include <getopt.h>
|
#include <libgen.h>
|
|
#include "cp_common.h"
|
#include "cp_network.h"
|
#include "cp_logger.h"
|
#include "cp_proc.h"
|
#include "cp_time.h"
|
#include "swe_tpdud.h"
|
#include "version.h"
|
|
static void stop_tpdu_service(SWE_TPDU *tpdu)
|
{
|
if(!tpdu)
|
return ;
|
|
log_dbg("release tpdu contex [%p]\n", tpdu);
|
|
if( tpdu->dlink )
|
{
|
log_nrml("stop tpdu service for downlink socket [%p:%d]\n", tpdu->dlink, tpdu->dlink->fd);
|
cp_fds_destroy_sock_clear(tpdu->dlink);
|
tpdu->dlink = NULL;
|
}
|
|
if( tpdu->ulink )
|
{
|
log_nrml("stop tpdu service for uplink socket [%p:%d]\n", tpdu->ulink, tpdu->ulink->fd);
|
cp_fds_destroy_sock_clear(tpdu->ulink);
|
tpdu->ulink = NULL;
|
}
|
|
t_free(tpdu);
|
}
|
|
int proc_uplink_event(CP_SOCK *ulink)
|
{
|
int rv;
|
CP_SOCK *dlink = NULL;
|
SWE_TPDU *tpdu = NULL;
|
|
if(!ulink || !(tpdu=ulink->privt) || !(dlink=tpdu->dlink))
|
{
|
log_err("tpdu address:[%p] ulink address:[%p] dlink address:[%p]\n", tpdu, ulink, dlink);
|
return -1;
|
}
|
|
if(ulink->status == SOCK_STAT_DISCONNECT)
|
{
|
goto stop_service;
|
}
|
|
if(ulink->event.events & CP_SOCK_EVENT_READ)
|
{
|
rv = cp_sock_recv(ulink);
|
if( 0==rv )
|
{
|
log_warn("Socket [%d %s:%d] remote socket [%s:%d] disconnect, remove it now\n",
|
ulink->fd, ulink->laddr, ulink->lport, ulink->raddr, ulink->rport);
|
goto stop_service;
|
}
|
else if(rv > 0)
|
{
|
log_nrml("Socket [%d %s:%d] receive %d bytes data:\n", ulink->fd, ulink->laddr, ulink->lport, rv);
|
cp_log_dump(LOG_LEVEL_DEBUG, ulink->rbuf->data, ulink->rbuf->len);
|
|
if(ulink->rbuf->len > 0)
|
{
|
cp_string_move(dlink->sbuf, ulink->rbuf);
|
cp_sock_send(dlink);
|
}
|
}
|
else
|
{
|
log_err("Socket [%d %s:%d] receive data failed: %s\n", ulink->fd, ulink->laddr, ulink->lport, strerror(errno));
|
}
|
}
|
else if(ulink->event.events & CP_SOCK_EVENT_IDLE_TIMEOUT)
|
{
|
log_warn("uplink socket [%d] is idle and to-do something here\n");
|
}
|
else if(ulink->event.events & CP_SOCK_EVENT_MSG_TIMEOUT)
|
{
|
log_warn("uplink socket [%d] message is timeout and to-do something here\n");
|
}
|
|
|
|
return 0;
|
|
stop_service:
|
stop_tpdu_service(tpdu);
|
return 0;
|
}
|
|
/* Connect to hostsim */
|
int tpdu_connect_uplink(SWE_TPDU *tpdu)
|
{
|
CP_SOCK *ulink;
|
CP_SOCK *dlink;
|
|
if(!tpdu || !(dlink=tpdu->dlink))
|
{
|
log_err("tpdu address [%p] dlink address [%p]\n", tpdu, dlink);
|
return -1;
|
}
|
|
ulink = tpdu->ulink;
|
|
ulink=cp_sock_connect_regist(dlink->fds, ulink, tpdu->raddr, tpdu->rport, 0, proc_uplink_event);
|
if( !ulink ) /* connect failure */
|
{
|
/* the uplink connect failure or connect already, then we should
|
* remove the downlink socket from task list */
|
log_err("connect to remote [%s:%d] failure\n", tpdu->raddr, tpdu->rport);
|
tpdu->ulink = NULL;
|
return -1;
|
}
|
else /* connecting in progress */
|
{
|
ulink->privt = tpdu;
|
tpdu->ulink = ulink;
|
log_info("connect to remote [%s:%d] in progress\n", tpdu->raddr, tpdu->rport);
|
cp_fds_add_sock_task(dlink);
|
dlink->event.events = 0; /* clear the events flag */
|
}
|
|
return 0;
|
}
|
|
int tpdu_service_route(CP_SOCK *dlink)
|
{
|
int rv = 0;
|
|
SWE_TPDU *tpdu;
|
|
if( !dlink )
|
return -1;
|
|
tpdu = dlink->privt;
|
|
/* If it's first data incoming from the dlink, then we should
|
* malloc a TPDU work context now and save it */
|
if( !tpdu )
|
{
|
if( !(tpdu=t_malloc(sizeof(*tpdu))) )
|
{
|
log_err("Malloc TPDU work contex failure\n");
|
goto stop_service;
|
}
|
else
|
{
|
SWE_TPDU *serv_tpdu;
|
log_info("malloc TPDU work contex [%p]\n", tpdu);
|
|
serv_tpdu = dlink->serv_sock->privt;
|
dlink->privt = tpdu;
|
tpdu->dlink = dlink;
|
strcpy(tpdu->raddr, serv_tpdu->raddr);
|
tpdu->rport = serv_tpdu->rport;
|
}
|
}
|
|
log_dbg("Process socket [%d %s:%d] with event [%d]\n", dlink->fd, dlink->laddr, dlink->lport, dlink->event.events);
|
|
/* If there is data incoming from this socket, now we receive the data */
|
if(dlink->event.events & CP_SOCK_EVENT_READ)
|
{
|
rv = cp_sock_recv(dlink);
|
if( rv == 0 )
|
{
|
log_warn("Socket [%d %s:%d] remote socket [%s:%d] disconnect, remove it now\n",
|
dlink->fd, dlink->laddr, dlink->lport, dlink->raddr, dlink->rport);
|
goto stop_service;
|
}
|
else if( rv < 0)
|
{
|
log_err("Socket [%d %s:%d] receive data failed: %s\n", dlink->fd, dlink->laddr, dlink->lport, strerror(errno));
|
goto stop_service;
|
}
|
|
/* Receive data OK */
|
log_nrml("Socket [%d %s:%d] receive %d bytes data:\n", dlink->fd, dlink->laddr, dlink->lport, rv);
|
cp_log_dump(LOG_LEVEL_DEBUG, dlink->rbuf->data, dlink->rbuf->len);
|
}
|
else if(dlink->event.events & CP_SOCK_EVENT_HUP)
|
{
|
log_warn("socket [%d] remote already disconnect\n", dlink->fd);
|
dlink->status = SOCK_STAT_DISCONNECT;
|
goto stop_service;
|
}
|
else if(dlink->event.events & CP_SOCK_EVENT_IDLE_TIMEOUT)
|
{
|
log_warn("socket [%d] is idle and to-do something here\n");
|
}
|
else if(dlink->event.events & CP_SOCK_EVENT_MSG_TIMEOUT)
|
{
|
log_warn("socket [%d] message is timeout and to-do something here\n");
|
}
|
|
/* If we have receive some data already, now we need do TPDU parser to
|
* get the remote server address and port */
|
if( dlink->rbuf->len > 0)
|
{
|
SWE_TPDU *arg = dlink->serv_sock->privt;
|
/* To-Do: parser downlink data here and get the uplink IP address and port */
|
tpdu->rport = arg->rport;
|
strncpy(tpdu->raddr, arg->raddr, sizeof(tpdu->raddr));
|
}
|
|
/* If not connect to the remote host or it's still connecting, then we do it again */
|
if( !tpdu->ulink || (tpdu->ulink->status==SOCK_STAT_CONNECTING))
|
{
|
log_nrml("tpdu dlink: %p\n", tpdu->dlink);
|
if( tpdu_connect_uplink(tpdu) < 0 )
|
goto stop_service;
|
}
|
|
/* If connect to the remote host already, now we send the data to the remote host */
|
if( !tpdu->ulink || (tpdu->ulink->status==SOCK_STAT_CONNECTED))
|
{
|
log_dbg("connect to remote [%s:%d] ok and send %d bytes data\n", tpdu->raddr, tpdu->rport, dlink->rbuf->len);
|
cp_fds_del_sock_task(dlink);
|
if(dlink->rbuf->len > 0)
|
{
|
cp_string_move(tpdu->ulink->sbuf, dlink->rbuf);
|
cp_sock_send(tpdu->ulink); /* send the data to the remote host */
|
return 0;
|
}
|
}
|
|
return 0;
|
|
stop_service:
|
stop_tpdu_service(tpdu);
|
tpdu = NULL;
|
return 0;
|
}
|
|
void print_usage(char *progname)
|
{
|
version(progname);
|
printf("Usage: %s [OPTION]...\n", progname);
|
printf(" %s is a handle program to create a tunnel between an incoming and outgoing FD\n", progname);
|
|
printf("\nMandatory arguments to long options are mandatory for short options too:\n");
|
|
printf(" -l[loglevel] To configure the logger level [0(DIS)...8(MAX)], default 4[NRML]\n");
|
printf(" -p[port ] To configure the listening port, default [%d]\n", TPDUD_PORT);
|
printf(" -i[RemoteIP] To configure the remote/outgoing IP, default [%s]\n", HOSTSIM_IP);
|
printf(" -o[outgoing] To configure the remote/outgoing Port, default [%d]\n", HOSTSIM_PORT);
|
printf(" -h[help ] Display this help information\n");
|
printf(" -v[version ] Display the program version\n");
|
printf("\n");
|
|
return ;
|
}
|
|
|
/********************************************************************************
|
* Description:
|
* Input Args:
|
* Output Args:
|
* Return Value:
|
********************************************************************************/
|
int main (int argc, char **argv)
|
{
|
CP_FDS *fds;
|
CP_SOCK *sock;
|
SWE_TPDU tpdu = {.lport=TPDUD_PORT, .raddr=HOSTSIM_IP, .rport=HOSTSIM_PORT};
|
int opt;
|
int loglevel = LOG_LEVEL_NRML;
|
|
struct option long_options[] =
|
{
|
{"loglevel", required_argument, NULL, 'l'},
|
{"port", required_argument, NULL, 'p'},
|
{"host", required_argument, NULL, 'i'},
|
{"outgoing", required_argument, NULL, 'o'},
|
{"version", no_argument, NULL, 'v'},
|
{"help", no_argument, NULL, 'h'},
|
{NULL, 0, NULL, 0}
|
};
|
|
while ((opt = getopt_long(argc, argv, "l:p:i:o:vh", long_options, NULL)) != -1)
|
{
|
switch (opt)
|
{
|
case 'l':
|
loglevel = atoi(optarg);
|
break;
|
|
case 'p':
|
tpdu.lport = atoi(optarg);
|
break;
|
|
case 'i':
|
strncpy(tpdu.raddr, optarg, sizeof(tpdu.raddr));
|
break;
|
|
case 'o':
|
tpdu.rport = atoi(optarg);
|
break;
|
|
case 'v':
|
version(basename(argv[0]));
|
return EXIT_SUCCESS;
|
|
case 'h':
|
print_usage(basename(argv[0]));
|
return EXIT_SUCCESS;
|
|
default:
|
break;
|
}
|
}
|
|
//if (!cp_log_init(NULL, "tpdud.log", LOG_LEVEL_MAX, LOG_ROLLBACK_NONE) || cp_log_open())
|
//if (!cp_log_init(NULL, "tpdud.log", loglevel, LOG_ROLLBACK_SIZE) || cp_log_open())
|
if (!cp_log_init(NULL, DBG_LOG_FILE, LOG_LEVEL_MAX, LOG_ROLLBACK_NONE) || cp_log_open())
|
//if (!cp_log_init(NULL, DBG_LOG_FILE, loglevel, LOG_ROLLBACK_NONE) || cp_log_open())
|
goto cleanup;
|
|
cp_install_proc_signal();
|
|
if( !(fds=cp_fds_init(NULL, CP_DEF_MAX_EVENTS, CP_DEF_FDS_TIMEOUT)) )
|
goto cleanup;
|
|
if( !(sock=cp_sock_server_regist(fds, NULL, tpdu.lport, 0, tpdu_service_route, (void *)&tpdu)) )
|
goto cleanup;
|
|
while( !g_cp_signal.stop )
|
{
|
cp_fds_detect_event(fds);
|
cp_fds_proc_event(fds);
|
cp_sock_detect_timeout(fds);
|
micro_second_sleep(10);
|
}
|
|
cleanup:
|
cp_sock_term_all_service_clear(fds);
|
cp_log_term();
|
return 0;
|
} /* ----- End of main() ----- */
|
