void Connection::setUp(const SetsVals& s) {
convertor->setUp(s);
sets = s;
initSock(sockMain, s.portMain);
initSock(sockAux, s.portAux);
}
/*********************************************************************
功能：构造函数，作初始化工作
参数：remoteIP，对方IP址
remotePort，本方端口号
loaclPort，本地端口号，默认值为0。当为0时，表示任意绑定一个端口号
返回：无
作者：叶文林 2012-08-24
*********************************************************************/
CUDPSocket::CUDPSocket(const char * remoteIP,WORD remotePort,WORD loaclPort)
: CCommunicationSocket()
{
#ifdef WL_OS_CORE_WIN
//win socket需要
WORD wVersionRequested;
WSADATA wsaData;
int err;
wVersionRequested = MAKEWORD( 2, 2 );
err = WSAStartup( wVersionRequested, &wsaData );
if ( err != 0 ) {
// Tell the user that we could not find a usable
// WinSock DLL.
return;
}
//--------------------------
#endif
//设置发送地址
setSockaddr(remoteIP,remotePort,&m_sendRemoteAddr);
//初始化SOCKET
struct sockaddr_in addr;
initSock(&m_hSocket,&addr,loaclPort);
}
bool Socket::initialize(int port, const std::string &add)
{
this->_port = port;
if (!initSock(add))
return (false);
return (true);
}
int init(void)
{
static char fn[]="init()";
errno = 0;
if( (atexit(&doProperClose)) != 0){
snprintf(mainDbgBuffer,sizeof(mainDbgBuffer),"atexit reg failed. err:%d %s",errno,strerror(errno));
dbgLog(FATAL,fn,__LINE__,mainDbgBuffer);
return -1;
}
if((installSignalHdlr()) < 0){
dbgLog(FATAL,fn,__LINE__,"Signal Hdlr Install Failed.");
return -1;
}
if((i2cFd=openI2CBus(I2C_CHA_2,devAddr)) <= 0){
dbgLog(FATAL,fn,__LINE__," I2C Init Failed.");
return -1;
}
if((mcUartFd=openSerPort(BB_MC_UART_NUM)) <= 0){
dbgLog(FATAL,fn,__LINE__,"Serial Port Init Failed");
return -1;
}
if( (initSock(QC_LISTN_PORT)) < 0){
dbgLog(FATAL,fn,__LINE__,"Socket Init Failed");
return -1;
}
return 0;
}
int main(int argc, char* argv[]) {
while (!initSock());
SOCKET sockServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sockServer == INVALID_SOCKET) {
clearSock(sockServer);
return -1;
}
sockaddr_in serverAddr = { 0 };
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.S_un.S_addr = INADDR_ANY;
serverAddr.sin_port = htons(PORT);
if (bind(sockServer, (sockaddr*)&serverAddr, sizeof(sockaddr))) {
clearSock(sockServer);
return -1;
}
WSAEVENT listenEvent = WSACreateEvent();
long eventType = FD_ACCEPT | FD_CLOSE;
WSAEventSelect(sockServer, listenEvent, eventType);
printf("******************************************************************************\n");
printf("**********welcome to use the high-big-up server built by lancelot************");
printf("********************************************************************************\n");
printf("\nwaiting...\n");
if (listen(sockServer, SOMAXCONN) == SOCKET_ERROR) {
clearSock(sockServer);
printf("\n bye-bye \n");
return -1;
}
arrSocket[g_total] = sockServer;
arrEvent[g_total++] = listenEvent;
char buf[1024] = { 0 };
SOCKET sockClient = INVALID_SOCKET;
WSANETWORKEVENTS netWorkEvent = { 0 };
long clientEventType = FD_CLOSE | FD_READ | FD_WRITE;
while (true) {
g_index = WSAWaitForMultipleEvents(g_total, arrEvent, false, 100, false);
if (g_index == WSA_WAIT_TIMEOUT)
continue;
WSAEnumNetworkEvents(arrSocket[g_index - WSA_WAIT_EVENT_0], arrEvent[g_index - WSA_WAIT_EVENT_0], &netWorkEvent);
if(!eventFunc(netWorkEvent, sockClient, buf, clientEventType))
continue;
printf("get a message!\n");
}
if (sockServer != INVALID_SOCKET)
closesocket(sockServer);
WSACleanup();
return 0;
}
int main(int argc, char **argv) {
int ret;
int clientSock;
int size;
char buf[1024];
char prefix[32];
int i;
int n;
socklen_t len;
struct sockaddr_in clientAddr;
if(initSock(8000) < 0)
return -1;
while(1) {
n = mSelect();
if(FD_ISSET(socks[0], &rfds)) {
size = sizeof(clientAddr);
clientSock = accept(socks[0], (struct sockaddr *)&clientAddr, &size);
if(clientSock < 0) {
perror("Accept failed");
continue;
}
addSock(clientSock);
}
for(i=1; i<=maxNum; i++) {
if(socks[i] == -1)
continue;
if(FD_ISSET(socks[i], &rfds)) {
size = recv(socks[i], buf, 1023, 0);
if(size < 0) {
if(errno == ECONNRESET)
removeSock(i);
else
perror("recv error");
}
else if(size == 0) {
removeSock(i);
}
getpeername(socks[i], (struct sockaddr *)&clientAddr, &len);
char *ip = inet_ntoa(clientAddr.sin_addr);
sprintf(prefix, "[%s]:", ip);
sendMsg(prefix, strlen(prefix));
sendMsg(buf, size);
}
}
}
close(socks[0]);
return 0;
}
int main(int argc, char *argv[])
{
/* check command line args. */
if(argc < 4){
printf("usage : %s <RouterID> <LogFileName> <Initialization file> \n", argv[0]);
exit(1);
}
char *router_id;
char *log_filename;
char *init_file;
FILE *log_file;
int nbytes;
// Extract arguments
router_id = argv[1];
log_filename = argv[2];
init_file = argv[3];
Router router;
router = router_init(*router_id,init_file);
//printf("Router init:\n");
//print_router(router);
// Open log file
log_file = fopen(log_filename, "wb");
if (!log_file)
{
printf("Failed open log file %s for router %s.\n", argv[2], argv[1]);
exit(1);
}
router = initSock(router);
//printf("Router after initSock:\n");
//print_router(router);
// Initialize LSP of this router
LSP_init(&router);
print_LSP(&router.self_packet,log_filename);
LSP lsp = router.self_packet;
// Each router has an array of recently received packets
// Receive buffer
//LSP buffer_packet;
LSP templsp;
//LSP checklsp;
char* buffer = malloc(sizeof(LSP));
//bzero(buffer,sizeof(buffer));
//memcpy(buffer,(char*) &lsp, sizeof(LSP));
//memcpy((char*) &checklsp, buffer, sizeof(LSP));
//print_LSP(&checklsp, log_file);
//printf("router id: %c\nsequence number: %d\n sizeof: %d\n",checklsp.router.ID,checklsp.seq_num, (int) sizeof(lsp));
// initialize router routing table
routing_table_init(&router);
print_routing_table(&router, log_filename);
fclose(log_file);
// ??
int i, j;
fd_set readSet;
fd_set tempReadSet;
FD_ZERO(&readSet);
FD_ZERO(&tempReadSet);
//first try to connect to neighbors
for(i = 0; i< router.nbrs_count; i++)
{
if(TCPconnect(router.nbrs[i]) < 0)
router.nbrs[i].connectedR = 0;
else
router.nbrs[i].connectedR = 1;
}
//then listen
for(i = 0; i< router.nbrs_count; i++)
{
TCPlisten(router.nbrs[i]);
FD_SET(router.nbrs[i].localSock,&readSet);
}
int highSock;
highSock = router.nbrs[0].localSock;
for(i = 0; i < router.nbrs_count-1; i++ )
{
highSock = router.nbrs[i].localSock > router.nbrs[i+1].localSock? router.nbrs[i].localSock: router.nbrs[i+1].localSock;
}
int counter = 0;
struct timeval tv;
tv.tv_sec = 5;
tv.tv_usec = 0;
// Select: while router is listening, it waits for one or more neighbors
// to connect.
for(;;)
{
tv.tv_sec = 5;
tv.tv_usec = 0;
tempReadSet = readSet;
printf("- %d\n", counter);
if(select(highSock+1, &tempReadSet, 0, 0, &tv) < 0)
{
printf("select error!\n");
}
//CHECK FD
for(i = 0; i< router.nbrs_count; i++)
{
// for select: Check if there's a connection or not
if(FD_ISSET(router.nbrs[i].localSock, &tempReadSet))
{
// Accept connections
if( router.nbrs[i].connectedS == 0)
{
int newSock;
if ((newSock = TCPaccept(router.nbrs[i])) > -1)
{
router.nbrs[i].connectedS= 1;
router.nbrs[i].localSock = newSock;
printf("sock: %d\n",router.nbrs[i].localSock);
printf("connectedS: %d\n",router.nbrs[i].connectedS);
FD_SET(router.nbrs[i].localSock,&readSet);
if(highSock < newSock)
highSock = newSock;
}
}
// Receive LSPs
else
{
bzero(buffer,sizeof(LSP));
socklen_t size = sizeof(&router.nbrs[i].localAddr);
if(recvfrom(router.nbrs[i].localSock, buffer, sizeof(LSP), 0, (struct sockaddr *) &router.nbrs[i].localAddr, &size) <0)
{
printf("error receiving from node %s\n", router.nbrs[i].ID);
}
else
{
printf("LSP received from %s \n",router.nbrs[i].ID);
memcpy((char *)&templsp, buffer, sizeof(LSP));
//print_LSP(&templsp,log_file);
// Check if received lsp is new
int check_lsp_flag = check_LSP(&router, &templsp);
if (check_lsp_flag == 1 || check_lsp_flag == 2)
{
// Log if LSP caused change in routing table.
if(check_lsp_flag == 2)
{
print_LSP(&templsp, log_filename);
print_routing_table(&router,log_filename);
}
// 2. Flood to all links, except where it came from
for(j = 0; j<router.nbrs_count; j++)
{
if((j != i) && router.nbrs[i].connectedR == 1)
{
//buffer = malloc(sizeof(LSP));
//bzero(buffer, sizeof(LSP));
//memcpy(buffer, (char*) &lsp, sizeof(LSP));
//memcpy((char *)&templsp, buffer, sizeof(LSP));
nbytes = sendto(router.nbrs[j].remoteSock, buffer, LSPSIZE, MSG_NOSIGNAL, (struct sockaddr*)&router.nbrs[j].remoteAddr, sizeof(router.nbrs[j].remoteAddr));
if (nbytes == -1)
{
printf("Failed to send on link: %s, %d, %s, %d\n",
router.nbrs[i].src_ID, router.nbrs[i].send_port,
router.nbrs[i].ID, router.nbrs[i].recv_port);
}
else
{
printf("Forward LSP from %s to %s\n", templsp.routerID, router.nbrs[j].ID);
//print_LSP(&templsp, log_file);
}
}
}
}
}
}
}
}
sleep(5);
// Try to connect again.
for(i = 0; i< router.nbrs_count; i++)
{
if(router.nbrs[i].connectedS == 1 &&router.nbrs[i].connectedR == 0)
{
if(TCPconnect(router.nbrs[i]) < 0)
{
printf("failed to connect to %s \n", router.nbrs[i].ID);
router.nbrs[i].connectedR = 0;
}
else
router.nbrs[i].connectedR = 1;
}
}
// initial and periodic flooding: Send LSP to connected links.
lsp.seq_num++;
for(i = 0; i<router.nbrs_count; i++)
{
if(router.nbrs[i].connectedR == 1)
{
buffer = malloc(sizeof(LSP));
bzero(buffer, sizeof(LSP));
memcpy(buffer, (char*) &lsp, sizeof(LSP));
memcpy((char *)&templsp, buffer, sizeof(LSP));
nbytes = sendto(router.nbrs[i].remoteSock, buffer, sizeof(LSP), 0, (struct sockaddr*)&router.nbrs[i].remoteAddr, sizeof(router.nbrs[i].remoteAddr));
if (nbytes == -1)
{
printf("Failed to send on link: %s, %d, %s, %d\n",
router.nbrs[i].src_ID, router.nbrs[i].send_port,
router.nbrs[i].ID, router.nbrs[i].recv_port);
}
else
{
printf("Send LSP to: %s\n", router.nbrs[i].ID);
//print_LSP(&templsp, log_file);
}
}
}
counter ++;
}
fclose(log_file);
return 0;
// Set router timer
//time_t curr_time;
//time(&router.timestamp);
// some connection shit
/*
// check time, send self lsp on all ports with established link
time(&curr_time);
if (difftime(curr_time, router.timestamp) >= (double)5.0)
{
router.timestamp = curr_time;
// update lsp seq
router.self_packet.seq++;
for (i=0 ; i<router.nbrs_count ; i++)
{
if (router.nbrs[i].connected)
{
nbytes = send(socket?, router.self_pakcet, sizeof(LSP), 0);
if (nbytes == -1)
{
printf("Failed to send on link: %s, %d, %s, %d\n",
router.nbrs[i].src_ID, router.nbrs[i].send_port,
router.nbrs[i].ID, router.nbrs[i].recv_port);
}
else
{
printf("Send LSP to: %s\n", router.nbrs[i].ID);
}
}
}
}
int lsp_update_flag;
// Receive LSP from all ports with "connected" neighbors
for (i=0 ; i<router.nbrs_count ; i++)
{
if (router.nbrs[i].connected)
{
nbytes = recv(router.nbrs[i].connect_fd, &buffer_packet, sizeof(LSP), 0);
if (nbytes > 0)
{
printf("LSP received from ID %s, seq %d\n", buffer_packet.router.ID, buffer_lsp.seq_num);
// store recvd lsp into database and determine if need forwarding
// also determine if need update topology and recompute
lsp_update_flag = update_LSP_list(&router, &buffer_lsp);
if (lsp_update_flag == 1)
{
// 1. Run Dijkstra!
printf("Update routing table...\n");
if (update_routing_table(&(router), &buffer_packet))
{
time(&curr_time);
sprintf(tmp_char_buffer, "UTC:\t%s", asctime(gmtime(&curr_time)));
printf("%s",tmp_char_buffer);
fwrite(tmp_char_buffer, sizeof(char), strlen(tmp_char_buffer), log_file);
print_lsp(&buffer_packet, log_file);
log_routing_table(&router, log_file);
}
// 2. Flood LSP to all outgoing links, except where it came from
buffer_pacekt.ttl--;
int j;
for (j=0; j<router.nbrs_count; j++)
{
if ((j != i) && (router.nbrs[j].connected))
{
nbytes = send(router.nbrs[j].connect_fd, &buffer_packet, sizeof(LSP), 0);
if (nbytes == -1)
{
printf("Failed to send on link: %s, %d, %s, %d\n",
router.nbrs[i].src_ID, router.nbrs[i].send_port,
router.nbrs[i].ID, router.nbrs[i].recv_port);
}
else
{
printf("Forward LSP from %s to %s\n", buffer_packet.routerID, router.nbrs[j].ID);
}
}
}
}
if(lsp_update_flag == 2)
{
// run dijkstra's algorithm
printf("Update routing table...\n");
if (update_routing_table(&(router), &buffer_packet))
{
time(&curr_time);
sprintf(tmp_char_buffer, "UTC:\t%s", asctime(gmtime(&curr_time)));
printf("%s",tmp_char_buffer);
fwrite(tmp_char_buffer, sizeof(char), strlen(tmp_char_buffer), log_file);
print_lsp(&buffer_packet, log_file);
log_routing_table(&router, log_file);
}
}*/
//}
//}
//}
// end if
}
ServerSocket::ServerSocket(sa_family_t family, in_port_t port, const char* ip){
initSock();
addr = Address(family, port, ip);
}
ServerSocket::ServerSocket(Address theAddr){
initSock();
addr = theAddr;
}
void* network_process(void* param1)
{
int sock; // sockets.
int nfound, maxfd;
const char *port = SERVER_PORT;
fd_set rmask, mask;
static struct timeval timeout = { 0, 500000 }; // .5 sec //
struct u_struct u;
int uSize=sizeof(struct u_struct);
struct sockaddr_in clientName;
int clientLength=sizeof(clientName);
int retval;
static int k = 0;
int logFile;
struct timeval tv;
struct timezone tz;
char logbuffer[100];
unsigned int seq = 0;
volatile int bytesread;
// print some status messages
ROS_INFO("Starting network services...");
ROS_INFO(" u_struct size: %i",uSize);
ROS_INFO(" Using default port %s",port);
///// open log file
logFile = open("err_network.log", O_WRONLY | O_CREAT | O_APPEND | O_NONBLOCK , 0664);
if ( logFile < 0 )
{
ROS_ERROR("ERROR: could not open log file.\n");
exit(1);
}
gettimeofday(&tv,&tz);
sprintf(logbuffer, "\n\nOpened log file at %s\n", ctime(&(tv.tv_sec)) );
retval = write(logFile,logbuffer, strlen(logbuffer));
///// open socket
sock = initSock(port);
if ( sock <= 0)
{
ROS_ERROR("socket: service failed to initialize socket. (%d)\n",logFile);
exit(1);
}
///// setup sendto address
memset(&clientName, 0, sizeof(clientName));
clientName.sin_family = AF_INET;
inet_aton(SERVER_ADDR, &clientName.sin_addr);
clientName.sin_port = htons((u_short)atoi(port));
clientLength=sizeof(clientName);
///// initialize data polling
FD_ZERO(&mask);
FD_SET(sock, &mask);
maxfd=sock;
ROS_INFO("Network layer ready.");
///// Main read/write loop
while ( ros::ok() )
{
rmask = mask;
timeout.tv_sec = 2; // hack:reset timer after timeout event.
timeout.tv_usec = 0; // ""
// wait for i/o lines to change state //
nfound = select(maxfd+1, &rmask, (fd_set *)0, (fd_set *)0, &timeout);
// Select error
if (nfound < 0)
{
if (errno == EINTR)
{
printf("interrupted system call\n");
continue;
}
perror("select");
break;
}
// Select timeout: nothing to do
if (nfound == 0)
{
fflush(stdout);
continue;
}
// Select: data on socket
if (FD_ISSET( sock, &rmask))
{
bytesread = recvfrom(sock,
&u,
uSize,
0,
NULL,
NULL);
if (bytesread != uSize){
ROS_ERROR("ERROR: Rec'd wrong ustruct size on socket!\n");
FD_CLR(sock, &rmask);
continue;
}
k++;
if (k==1) {
log_msg("rec'd first socket data");
} else if (k % 10000 == 0) {
log_msg("rec'd socket data x10000");
}
//
// if (u.checksum != UDPChecksum(&u)) // Check checksum
// {
// gettimeofday(&tv,&tz);
// sprintf(logbuffer, "%s Bad Checksum -> rejected packet\n", ctime(&(tv.tv_sec)) );
// ROS_ERROR("%s Bad Checksum -> rejected packet\n", ctime(&(tv.tv_sec)) );
// retval = write(logFile,logbuffer, strlen(logbuffer));
//
// }
// else
if (u.sequence == 0) // Zero seqnum means reflect packet to sender
{
gettimeofday(&tv,&tz);
sprintf(logbuffer, "%s Zero sequence -> reflect packet\n", ctime(&(tv.tv_sec)) );
ROS_INFO("%s Zero sequence -> reflect packet\n", ctime(&(tv.tv_sec)) );
retval = write(logFile,logbuffer, strlen(logbuffer));
}
else if (u.sequence > seq+1) // Skipping sequence number (dropped)
{
gettimeofday(&tv,&tz);
sprintf(logbuffer, "%s Skipped (dropped?) packets %d - %d\n", ctime(&(tv.tv_sec)),seq+1, u.sequence-1 );
ROS_WARN("%s Skipped (dropped?) packets %d - %d\n", ctime(&(tv.tv_sec)),seq+1, u.sequence-1 );
retval = write(logFile,logbuffer, strlen(logbuffer));
seq = u.sequence;
}
else if (u.sequence == seq) // Repeated sequence number
{
gettimeofday(&tv,&tz);
sprintf(logbuffer, "%s Duplicated packet %d - %d\n", ctime(&(tv.tv_sec)),seq, u.sequence );
ROS_ERROR("%s Duplicated packet %d - %d\n", ctime(&(tv.tv_sec)),seq, u.sequence );
retval = write(logFile,logbuffer, strlen(logbuffer));
}
else if (u.sequence > seq) // Valid packet
{
seq = u.sequence;
recieveUserspace(&u,uSize);
}
else if (seq > 1000 && u.sequence < seq-1000) // reset sequence(skipped more than 1000 packets)
{
gettimeofday(&tv,&tz);
sprintf(logbuffer, "%s Sequence numbering reset from %d to %d\n", ctime(&(tv.tv_sec)),seq, u.sequence );
ROS_INFO("%s Sequence numbering reset from %d to %d\n", ctime(&(tv.tv_sec)),seq, u.sequence );
seq = u.sequence;
retval = write(logFile,logbuffer, strlen(logbuffer));
}
else
{
gettimeofday(&tv,&tz);
sprintf(logbuffer, "%s Out of sequence packet %d\n", ctime(&(tv.tv_sec)),seq );
ROS_ERROR("%s Out of sequence packet %d\n", ctime(&(tv.tv_sec)),seq );
retval = write(logFile,logbuffer, strlen(logbuffer));
}
}
#ifdef NET_SEND
sendto ( sock, (void*)&v, vSize, 0,
(struct sockaddr *) &clientName, clientLength);
#endif
} // while(1)
close(sock);
ROS_INFO("Network socket is shutdown.");
return(NULL);
} // main - server.c //
