static int listen_to_MPS( struct sockaddr_atmsvc ctrl_listen_addr ){
/* soketti, joka kuuntelee MPC:n Control ATM-osoitteessa */
mpc_control.MPS_listen_socket = get_listen_socket(&ctrl_listen_addr);
if (mpc_control.MPS_listen_socket < 0)
return -1;
return 0;
}
bool UDTPPeer::send_to(UDTPPacket* sendPacket){ /*Send from the server usually*/
if(get_unique_id() != sendPacket->get_unique_id() ) {
std::cout << "PACKET WILL NOT SEND: Packet's unique ID does not match with PEER's unique ID. This PEER may have disconnected (and removed from polling and peer list) and this packet was assigned that PEER's last position." << std::endl;
return false;
}
std::cout << "HOST has sent out a packet" << std::endl;
send(get_listen_socket(), sendPacket->get_raw_buffer(), sendPacket->get_packet_size(), 0); /*The UDTPPAclet's socket id is used to denote where to send the packet. The socket id is handled in the polling threads. For HOSTS, the socket id
will be the receiving socket's file descriptor. For PEER, it will always be its own _listenSocket being that that is where the central receiving and sending
happens.*/
}
/*
* func_list
* perform directory listing i.e: ls
*/
void func_list( char *command)
{
if( !flag_connected ) {
printf("Not flag_connected.n");
return;
}
/*
* obtain a listening socket
*/
if( get_listen_socket() < 0) {
printf("Cannot obtain a listen socket.n");
return;
}
/*
* parse command
*/
if( !strcmp(command,"ls") ) {
sprintf(tmp_buffer,"NLSTrn");
}
else if( !strcmp(command,"dir") )
sprintf(tmp_buffer,"LISTrn");
else if( !strncmp(command, "ls ",3)) {
while( *command == ' ') command++;
sprintf(tmp_buffer,"LIST %srn",&command[3]);
}
/*
* send command to server and get response
*/
send_ctrl_msg(tmp_buffer,strlen(tmp_buffer));
memset(tmp_buffer,0,1024);
k=get_host_reply();
TranslateReply(k);
/*
* accept server's connection
*/
if(accept_connection() < 0) {
printf("Cannot accept connection.n");
return;
}
close_listen_socket(); /* close listening socket */
/*
* display directory listing.
*/
while( data_msg(tmp_buffer,1024) > 0) {
fflush(stdout);
printf(tmp_buffer);
memset(tmp_buffer,0,1024);
}
/*
* read response
*/
k=get_host_reply();
TranslateReply(k);
}
/**
* initialize struct server, include listen socket
*/
int server_init(struct server *server, char *ip, unsigned short port, int backlog)
{
strncpy(server->name, ip, NAME_MAX);
server->ip = ip;
server->port = port;
server->backlog = backlog;
server->listening_socket = get_listen_socket(ip, port, backlog);
if (server->listening_socket < 0) {
fprintf(stderr, "get listen socket failed\n");
return -1;
}
memset(server->connfd_list, 0, sizeof(server->connfd_list));
server->connfd_list[server->listening_socket] = 1;
return 0;
}
int main(int argc, char **argv){
int listen_socket;
int opt_ret = 0;
struct k_message msg;
struct sockaddr_atmsvc control_listen_addr;
struct sockaddr_atmsvc mps_ctrl_addr;
struct sockaddr_atmsvc lec_addr;
memset(&control_listen_addr,0,sizeof(struct sockaddr_atmsvc));
memset(&mpc_control.data_listen_addr,0,sizeof(struct sockaddr_atmsvc));
memset(&lec_addr,0,sizeof(struct sockaddr_atmsvc));
memset(&mps_ctrl_addr,0,sizeof(struct sockaddr_atmsvc));
memset(&msg,0,sizeof(struct k_message));
memset(&mpc_control,0,sizeof(mpc_control));
mpc_control.elan_name[32] = '\0';
init_default_addresses(&control_listen_addr, &mpc_control.data_listen_addr);
while( opt_ret != -1 ){
opt_ret = getopt(argc, argv, "h:s:l:c:L:n:C:i:m:");
switch(opt_ret) {
case 'h':
usage(argv[0]);
exit(0);
break;
case 's':
if(text2atm(optarg,(struct sockaddr *)&control_listen_addr,
sizeof(struct sockaddr_atmsvc),T2A_SVC | T2A_NAME)<0){
printf("mpcd: main.c: text2atm failed.\n");
usage(argv[0]);
exit(1);
}
memcpy(mpc_control.OWN_ATM_ADDRESS,control_listen_addr.sas_addr.prv, ATM_ESA_LEN);
break;
case 'l':
if(text2atm(optarg,(struct sockaddr *)&mpc_control.data_listen_addr,
sizeof(struct sockaddr_atmsvc),T2A_SVC | T2A_NAME)<0){
printf("mpcd: main.c: text2atm failed.\n");
usage(argv[0]);
exit(1);
}
break;
case 'c':
if(text2atm(optarg,(struct sockaddr *)&mps_ctrl_addr,
sizeof(struct sockaddr_atmsvc),T2A_SVC | T2A_NAME)<0){
printf("mpcd: main.c: text2atm failed.\n");
usage(argv[0]);
exit(1);
}
memcpy(mpc_control.MPS_CTRL_ATM_ADDR,mps_ctrl_addr.sas_addr.prv,ATM_ESA_LEN);
mpc_control.mps_ctrl_addr_set = 1;
break;
case 'L':
if(text2atm(optarg,(struct sockaddr *)&lec_addr,
sizeof(struct sockaddr_atmsvc),T2A_SVC | T2A_NAME)<0){
printf("mpcd: main.c: text2atm failed.\n");
usage(argv[0]);
exit(1);
}
memcpy(mpc_control.LEC_ADDRESS,lec_addr.sas_addr.prv,ATM_ESA_LEN);
mpc_control.use_lecs = 1;
break;
case 'n':
strncpy(mpc_control.elan_name,optarg,33);
break;
case 'C':
if(text2atm(optarg,(struct sockaddr *)&mpc_control.lecs_address,
sizeof(struct sockaddr_atmsvc),T2A_SVC | T2A_NAME)<0){
printf("mpcd: main.c: text2atm failed.\n");
usage(argv[0]);
exit(1);
}
break;
case 'm':
strncpy(mpc_control.MPS_MAC_ADDRESS,optarg,13);
mpc_control.mps_mac_addr_set = 1;
break;
case 'i':
mpc_control.INTERFACE_NUMBER = atoi(optarg);
break;
}
}
if (argc != optind) {
usage(argv[0]);
exit(1);
}
while(1){
create_kernel_socket(mpc_control.INTERFACE_NUMBER);
if(mpc_control.use_lecs){
get_mpc_config(&mpc_control.lecs_address, mpc_control.LEC_ADDRESS, mpc_control.elan_name);
}
msg.type = SET_MPC_CTRL_ADDR;
memcpy(msg.MPS_ctrl,mpc_control.OWN_ATM_ADDRESS,ATM_ESA_LEN);
if (send_to_kernel(&msg) < 0) {
printf("mpcd: main.c: send_to_kernel(SET_MPC_CTRL_ADDR) failed\n");
exit(1);
}
if(mpc_control.mps_mac_addr_set)
set_mps_mac_addr();
listen_to_MPS( control_listen_addr );
if ( (listen_socket = get_listen_socket(&mpc_control.data_listen_addr)) < 0)
{
printf("mpcd: main.c: listen_socket creation failed\n");
exit (1);
}
signal(SIGHUP, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
signal(SIGABRT, signal_handler);
signal(SIGTERM, signal_handler);
main_loop(listen_socket);
sleep(5);
printf("mpcd: main.c: going back to main loop...\n");
}
return 0;
}
int start_listener_addrinfo(
char *host_name,
int server_port,
void *(*process_meth)(void *))
{
struct addrinfo *adr_svr = NULL;
struct sockaddr adr_client;
struct sockaddr_in *in_addr;
struct sockaddr_in svr_address;
socklen_t len_inet;
int rc = PBSE_NONE;
int sockoptval;
int new_conn_port = -1;
int listen_socket = 0;
int total_cntr = 0;
unsigned short port_net_byte_order;
pthread_attr_t t_attr;
char err_msg[MAXPATHLEN];
char log_buf[LOCAL_LOG_BUF_SIZE + 1];
int ret = pbs_getaddrinfo(host_name, NULL, &adr_svr);
if (ret != 0)
{
/* hostname didn't resolve */
snprintf(err_msg, sizeof(err_msg),
"Error with getaddrinfo on host name %s. Error code = %d, '%s'.\n",
host_name, ret, gai_strerror(ret));
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, err_msg);
rc = PBSE_SOCKET_FAULT;
return rc;
}
port_net_byte_order = htons(server_port);
memcpy(&adr_svr->ai_addr->sa_data, &port_net_byte_order, sizeof(unsigned short));
memset(&svr_address, 0, sizeof(svr_address));
svr_address.sin_family = adr_svr->ai_family;
svr_address.sin_port = htons(server_port);
svr_address.sin_addr.s_addr = htonl(INADDR_ANY);
if ((listen_socket = get_listen_socket(adr_svr)) < 0)
{
/* Can not get socket for listening */
rc = PBSE_SOCKET_FAULT;
}
else if ((bind(listen_socket, (struct sockaddr *)&svr_address, sizeof(svr_address))) == -1)
{
/* Can not bind local socket */
rc = PBSE_SOCKET_FAULT;
}
else if (listen(listen_socket, 256) == -1)
{
/* Can not listener on local socket */
rc = PBSE_SOCKET_LISTEN;
}
else if ((rc = pthread_attr_init(&t_attr)) != 0)
{
/* Can not init thread attribute structure */
rc = PBSE_THREADATTR;
}
else if ((rc = pthread_attr_setdetachstate(&t_attr, PTHREAD_CREATE_DETACHED)) != 0)
{
/* Can not set thread initial state as detached */
pthread_attr_destroy(&t_attr);
}
else
{
// record this so it can be closed by children
listening_socket = listen_socket;
int exit_loop = FALSE;
int retry_tolerance = NUM_ACCEPT_RETRIES;
while (1)
{
long *args = NULL;
/* if successfully allocated args will be freed in process_meth */
args = (long *)calloc(3, sizeof(long));
if (args == NULL)
{
snprintf(log_buf, sizeof(log_buf), "failed to allocate argument space");
log_event(PBSEVENT_ERROR, PBS_EVENTCLASS_REQUEST, __func__, log_buf);
/* Let's try to recover */
sleep(5);
continue;
}
len_inet = sizeof(struct sockaddr);
if ((new_conn_port = accept(listen_socket, (struct sockaddr *)&adr_client, (socklen_t *)&len_inet)) == -1)
{
switch (errno)
{
case EMFILE:
case ENFILE:
case EINTR:
/* transient error, try again */
if (retry_tolerance-- <= 0)
{
exit_loop = TRUE;
snprintf(err_msg, sizeof(err_msg), "Exiting loop because we passed our retry tolerance: %d", errno);
}
else
sleep(1);
break;
default:
snprintf(err_msg, sizeof(err_msg), "error in accept %s - stopping accept loop", strerror(errno));
exit_loop = TRUE;
break;
}
if (exit_loop == TRUE)
{
if (args)
free(args);
break;
}
errno = 0;
}
else
{
retry_tolerance = NUM_ACCEPT_RETRIES;
sockoptval = 1;
setsockopt(new_conn_port, SOL_SOCKET, SO_REUSEADDR, (void *)&sockoptval, sizeof(sockoptval));
in_addr = (struct sockaddr_in *)&adr_client;
args[0] = new_conn_port;
args[1] = ntohl(in_addr->sin_addr.s_addr);
args[2] = htons(in_addr->sin_port);
if (debug_mode == TRUE)
{
process_meth((void *)args);
}
else
{
if (new_conn_port == PBS_LOCAL_CONNECTION)
{
snprintf(log_buf, LOCAL_LOG_BUF_SIZE, "Ignoring local incoming request %d", new_conn_port);
log_record(PBSEVENT_SYSTEM, PBS_EVENTCLASS_REQUEST, __func__, log_buf);
}
else
{
/* add_conn is not protocol independent. We need to
do some IPv4 stuff here */
add_conn(
new_conn_port,
FromClientDIS,
(pbs_net_t)ntohl(in_addr->sin_addr.s_addr),
(unsigned int)htons(in_addr->sin_port),
PBS_SOCK_INET,
NULL);
enqueue_threadpool_request(process_meth, args, request_pool);
}
}
}
if (debug_mode == TRUE)
{
if (total_cntr % 1000 == 0)
{
printf("Total requests: %d\n", total_cntr);
}
total_cntr++;
}
} /* END infinite_loop() */
pthread_attr_destroy(&t_attr);
/* all conditions for exiting the loop must populate err_msg */
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, __func__, err_msg);
}
if (listen_socket != -1)
close(listen_socket);
return(rc);
} /* END start_listener_addrinfo() */
int start_listener_addrinfo(
char *host_name,
int server_port,
void *(*process_meth)(void *))
{
struct addrinfo *adr_svr;
struct sockaddr adr_client;
struct sockaddr_in *in_addr;
struct sockaddr_in svr_address;
socklen_t len_inet;
int rc = PBSE_NONE;
int sockoptval;
int *new_conn_port = NULL;
int listen_socket = 0;
int total_cntr = 0;
unsigned short port_net_byte_order;
pthread_attr_t t_attr;
if (!(getaddrinfo(host_name, NULL, NULL, &adr_svr) == 0))
{
rc = PBSE_SOCKET_FAULT;
}
port_net_byte_order = htons(server_port);
memcpy(&adr_svr->ai_addr->sa_data, &port_net_byte_order, sizeof(unsigned short));
memset(&svr_address, 0, sizeof(svr_address));
svr_address.sin_family = adr_svr->ai_family;
svr_address.sin_port = htons(server_port);
svr_address.sin_addr.s_addr = htonl(INADDR_ANY);
if ((listen_socket = get_listen_socket(adr_svr)) < 0)
{
/* Can not get socket for listening */
rc = PBSE_SOCKET_FAULT;
}
else if ((bind(listen_socket, (struct sockaddr *)&svr_address, sizeof(svr_address))) == -1)
{
/* Can not bind local socket */
rc = PBSE_SOCKET_FAULT;
}
else if (listen(listen_socket, 256) == -1)
{
/* Can not listener on local socket */
rc = PBSE_SOCKET_LISTEN;
}
else if ((rc = pthread_attr_init(&t_attr)) != 0)
{
/* Can not init thread attribute structure */
rc = PBSE_THREADATTR;
}
else if ((rc = pthread_attr_setdetachstate(&t_attr, PTHREAD_CREATE_DETACHED)) != 0)
{
/* Can not set thread initial state as detached */
pthread_attr_destroy(&t_attr);
}
else
{
freeaddrinfo(adr_svr);
while (1)
{
len_inet = sizeof(struct sockaddr);
if((new_conn_port = (int *)calloc(1, sizeof(int))) == NULL)
{
printf("Error allocating new connection handle.\n");
break;
}
if ((*new_conn_port = accept(listen_socket, (struct sockaddr *)&adr_client, (socklen_t *)&len_inet)) == -1)
{
if (errno == EMFILE)
{
sleep(1);
printf("Temporary pause\n");
}
else
{
printf("error in accept %s\n", strerror(errno));
break;
}
errno = 0;
close(*new_conn_port);
free(new_conn_port);
new_conn_port = NULL;
}
else
{
sockoptval = 1;
setsockopt(*new_conn_port, SOL_SOCKET, SO_REUSEADDR, (void *)&sockoptval, sizeof(sockoptval));
if (debug_mode == TRUE)
{
process_meth((void *)new_conn_port);
}
else
{
/* add_conn is not protocol independent. We need to
do some IPv4 stuff here */
in_addr = (struct sockaddr_in *)&adr_client;
add_conn(
*new_conn_port,
FromClientDIS,
(pbs_net_t)ntohl(in_addr->sin_addr.s_addr),
(unsigned int)htons(in_addr->sin_port),
PBS_SOCK_INET,
NULL);
enqueue_threadpool_request(process_meth, new_conn_port);
/*pthread_create(&tid, &t_attr, process_meth, (void *)new_conn_port);*/
}
}
if (debug_mode == TRUE)
{
if (total_cntr % 1000 == 0)
{
printf("Total requests: %d\n", total_cntr);
}
total_cntr++;
}
}
if (new_conn_port != NULL)
{
free(new_conn_port);
}
pthread_attr_destroy(&t_attr);
log_event(PBSEVENT_JOB, PBS_EVENTCLASS_JOB, "net_srvr",
(char *)"Socket close of network listener requested");
}
close(listen_socket);
return(rc);
} /* END start_listener_addrinfo() */
bool UDTPPeer::send_from(UDTPPacket* sendPacket){ /*PEER from the peer itself!*/
std::cout << "PEER has sent out a packet" << std::endl;
send(get_listen_socket(), sendPacket->get_raw_buffer(), sendPacket->get_packet_size(), 0); /*The UDTPPAclet's socket id is used to denote where to send the packet. The socket id is handled in the polling threads. For HOSTS, the socket id
will be the receiving socket's file descriptor. For PEER, it will always be its own _listenSocket being that that is where the central receiving and sending
happens.*/
}
/* called to retrive a file from remote host */
void getfile( char *fname)
{
FILE *fp=NULL;
int fd, nTotal=0, nBytesRead=0, retval, aborted=0;
char *abortstr = "ABORrn", ch;
if( !fname || ! (*fname)) {
printf("No file specified.n");
return;
}
/*
* open the file with current mode
*/
if(! (fp=fopen(fname,(bMode==ASCII) ? "wt" : "wb"))) {
perror("file open");
return;
}
/*
* obtain a listen socket
*/
if( get_listen_socket() < 0) {
fclose(fp);
return;
}
/*
* send command to server and read response
*/
sprintf(tmp_buffer,"RETR %srn",fname);
if(!send_ctrl_msg(tmp_buffer,strlen(tmp_buffer))) {
fclose(fp);
return;
}
int l= get_host_reply();
if(l==550)return;
/*
* accept server connection
*/
if( accept_connection() <= 0) {
fclose(fp);
return;
}
/*
* now get file and store
*/
fd = fileno(fp);
printf("Type q and hit return to abortrn");
while( (nBytesRead=data_msg(tmp_buffer,1024)) > 0) {
write(fd,tmp_buffer,nBytesRead);
nTotal+=nBytesRead;
printf("%s : %d receivedr",fname,nTotal);
if( check_input() ) {
ch = getchar();
if( ch != 'n') {
while( getchar() != 'n') ; /* read 'til new line */
}
if( ch == 'q')
aborted = 1;
}
/*
* did we abort?
*/
if( aborted ) {
printf("rnAbort: Waiting for server to finish.");
send_ctrl_msg(abortstr,strlen(abortstr));
break;
}
}
if( aborted ) { // ignore everything if aborted.
while( (nBytesRead=data_msg(tmp_buffer,1024)) > 0);
get_host_reply();
}
/* (void)signal(SIGINT,OldHandler); */
printf("rn");
close(fd);
close_data_connection(hDataSocket);
/*/ ControlCHit = 0; */
get_host_reply();
}
/*
* put_file
*/
void put_file( char *fname)
{
FILE *fp=NULL;
int fd, nTotal=0, nBytesRead=0, retval, aborted=0;
char *abortstr = "ABORrn", ch;
/* void (*OldHandler)(int); */
if( !fname || ! (*fname)) {
printf("No file specified.n");
return;
}
if(! (fp=fopen(fname,(bMode==ASCII) ? "rt" : "rb"))) {
perror("file open");
return;
}
if( get_listen_socket() < 0) {
fclose(fp);
return;
}
/*
* send command to server & read reply
*/
sprintf(tmp_buffer,"STOR %srn",fname);
if(!send_ctrl_msg(tmp_buffer,strlen(tmp_buffer))) {
fclose(fp);
return;
}
int m=get_host_reply();
if(m==550)
return;
/*
* accept server connection
*/
if( accept_connection() <= 0) {
fclose(fp);
return;
}
/*
* now send file
*/
fd = fileno(fp);
printf("Type q and hit return to abortrn");
while( (nBytesRead=read(fd,tmp_buffer,1024)) > 0) {
send_data_msg(tmp_buffer,nBytesRead);
nTotal+=nBytesRead;
printf("%s : %d sentr",fname,nTotal);
if( check_input() ) {
ch = getchar();
if( ch != 'n') {
while( getchar() != 'n') ; /* read 'til new line */
}
if( ch == 'q')
aborted = 1;
}
/*
* send an abort command to server if we aborted.
*/
if( aborted ) {
printf("rnAbort: Waiting for server to finish.");
send_ctrl_msg(abortstr,strlen(abortstr));
break;
}
}
/*(void)signal(SIGINT,OldHandler); */
printf("rn");
/*
* close data connection
*/
close_data_connection(hDataSocket);
close(fd);
get_host_reply();
}
int main(int argc, char *argv[])
{
fd_set readfds;
int nfds;
int i, ret;
int listening_socket;
char *ip;
struct time_wait tw;
unsigned short port;
int listen_backlog;
struct timeval tv;
if (argc < 4) {
fprintf(stderr, "usage: %s <ip_addr> <port> <backlog>\n", argv[0]);
exit(1);
}
ip = argv[1];
port = (unsigned short)strtol(argv[2], NULL, 10);
listen_backlog = (int) strtol(argv[3], NULL, 10);
if ((listening_socket = get_listen_socket(ip, port, listen_backlog)) < 0) {
fprintf(stderr, "get listen socket failed\n");
exit(1);
}
nfds = 0;
time_wait_init(&tw, 5);
/* accept */
for(;;) {
FD_ZERO(&readfds);
register_select(listening_socket, &readfds, &nfds);
for (i = 0; i < client_num; i++) {
register_select(clients[i], &readfds, &nfds);
}
tv.tv_sec = 0;
tv.tv_usec = 100000;
ret = select(nfds, &readfds, NULL, NULL, &tv);
if (ret < 0) {
fprintf(stderr, "select failed: %s\n", strerror(errno));
} else if (ret == 0) {
time_wait_check(&tw);
if (tw.flag == 1) {
printf("time: %d\n", tw.count_time);
for (i = 0; i < client_num; i++) {
write(clients[i], &tw.count_time, sizeof(tw.count_time));
}
}
if (tw.flag == 2) {
printf("=================================\n");
printf("collect data from client\n");
printf("=================================\n");
}
} else {
if (FD_ISSET(listening_socket, &readfds)) {
add_client(listening_socket);
}
deal_client_fd(&readfds);
}
}//for end
close(listening_socket);
return 0;
}
