int main() {
int ID;
pthread_t recThread, sendThread;
_ACK = 0;
/****** Bloco de inicializacao da rede ********/
G = init(); // Abre os arquivos e configura a rede
printf("ID: "); // Solicita o ID do roteator instanciado
scanf("%d", &ID);
ID -= 1;
printf("\n");
if(ID > G->V || ID < 0) { // Valida o ID informado
printf("ID do roteador invalido\n");
return 0;
}
/*********************************************/
G->ID = ID;
/***********************************************************************/
/** Calcula os proximo salto para alcancar todos os outros roteadores **/
nextHop(G, ID);
/***********************************************************************/
/***********************************************************************/
/**** Cria uma thread para ouvir a porta e outra para enviar dados *****/
pthread_mutex_init(&lock, NULL);
pthread_create(&sendThread, NULL, (void *)interface, NULL);
pthread_create(&recThread, NULL, (void *)packetReceive, NULL);
pthread_join(sendThread, NULL);
pthread_cancel(recThread);
pthread_join(recThread, NULL);
/***********************************************************************/
digraphExit(G, ID);
return 0;
}
int NetworkHelperImplWindows::queryRoutingTable() {
MIB_IPFORWARD_TABLE2 *table = NULL;
NETIO_STATUS status;
status = GetIpForwardTable2(AF_INET, &table);
if (!NETIO_SUCCESS(status)) {
qDebug() << "GetIpForwardTable2 failed:" << status;
return 1;
}
for (ULONG i = 0; i < table->NumEntries; i++) {
MIB_IPFORWARD_ROW2 *row = table->Table + i;
IP_ADDRESS_PREFIX *prefix = &row->DestinationPrefix;
QHostAddress destAddr(ntohl(prefix->Prefix.Ipv4.sin_addr.S_un.S_addr));
QHostAddress nextHop(ntohl(row->NextHop.Ipv4.sin_addr.S_un.S_addr));
#ifdef _DEBUG
const QString debugLineFormat("%1/%2 via %3 metric %4 dev %5 # %6proto=%7, origin=%8");
QString debugLine = debugLineFormat.arg(
destAddr.toString(),
QString::number(prefix->PrefixLength),
nextHop.toString(),
QString::number(row->Metric),
(row->Loopback ? "lo" : QString::number(row->InterfaceIndex)),
(row->Immortal ? "immortal, " : ""),
QString::number(row->Protocol),
QString::number(row->Origin)
);
qDebug() << debugLine;
#endif
}
FreeMibTable(table);
return 0;
}
int main(int argc, char **argv) {
// ------------------------------------------------------------------------
// Handle commandline arguments
if (argc < 5) {
printf("usage: emulator -p <port> -f <filename>\n");
exit(1);
}
char *portStr = NULL;
const char *filename = NULL;
int cmd;
while ((cmd = getopt(argc, argv, "p:f:")) != -1) {
switch(cmd) {
case 'p': portStr = optarg; break;
case 'f': filename = optarg; break;
case '?':
if (optopt == 'p' || optopt == 'f')
fprintf(stderr, "Option -%c requires an argument.\n", optopt);
else if (isprint(optopt))
fprintf(stderr, "Unknown option -%c.\n", optopt);
else
fprintf(stderr, "Unknown option character '\\x%x'.\n", optopt);
exit(EXIT_FAILURE);
break;
default:
printf("Unhandled argument: %d\n", cmd);
exit(EXIT_FAILURE);
}
}
printf("Port : %s\n", portStr);
printf("File Name : %s\n", filename);
// Convert program args to values
int emulPort = atoi(portStr);
int maxTime = 1500;
int minTime = 500;
// Validate the argument values
if (emulPort <= 1024 ||emulPort >= 65536)
ferrorExit("Invalid emul port");
puts("");
srand(time(NULL));
initLog("log_file.txt");
// ------------------------------------------------------------------------
// Setup emul address info
struct addrinfo ehints;
bzero(&ehints, sizeof(struct addrinfo));
ehints.ai_family = AF_INET;
ehints.ai_socktype = SOCK_DGRAM;
ehints.ai_flags = AI_PASSIVE;
char localhost[80];
gethostname(localhost, sizeof(localhost));
// Get the emul's address info
struct addrinfo *emulinfo;
int errcode = getaddrinfo(localhost, portStr, &ehints, &emulinfo);
if (errcode != 0) {
fprintf(stderr, "emul getaddrinfo: %s\n", gai_strerror(errcode));
exit(EXIT_FAILURE);
}
// Loop through all the results of getaddrinfo and try to create a socket for emul
int sockfd;
struct addrinfo *sp;
for(sp = emulinfo; sp != NULL; sp = sp->ai_next) {
// Try to create a new socket
sockfd = socket(sp->ai_family, sp->ai_socktype, sp->ai_protocol);
if (sockfd == -1) {
perror("Socket error");
continue;
}
// Try to bind the socket
if (bind(sockfd, sp->ai_addr, sp->ai_addrlen) == -1) {
perror("Bind error");
close(sockfd);
continue;
}
break;
}
if (sp == NULL) perrorExit("Send socket creation failed");
else printf("emul socket created.\n");
struct sockaddr_in *tmp = (struct sockaddr_in *)sp->ai_addr;
unsigned long eIpAddr = tmp->sin_addr.s_addr;
//printf("eIpAddr: %lu\n", eIpAddr);
initTable(filename, tmp);
exit(0);
// ------------------------------------------------------------------------
// The Big Loop of DOOM
struct sockaddr_in *nextSock;
int shouldForward;
fd_set fds;
struct timespec *tv = malloc(sizeof(struct timespec));
tv->tv_sec = (long) 0;
tv->tv_nsec = 0;
int retval = 0;
int numRecv = 0;
int routesMade = 0;
unsigned long long start;
struct packet *dpkt;
struct ip_packet *pkt = malloc(sizeof(struct ip_packet));
void *msg = malloc(sizeof(struct ip_packet));
for (;;) {
FD_ZERO(&fds);
FD_SET(sockfd, &fds);
start = getTimeMS();
retval = pselect(sockfd + 1, &fds, NULL, NULL, tv, NULL);
// ------------------------------------------------------------------------
// receiving half
if (retval > 0 /*&& routesMade == 1*/) {
// Receive and forward packet
printf("retval > 0\n");
bzero(msg, sizeof(struct ip_packet));
size_t bytesRecvd = recvfrom(sockfd, msg, sizeof(struct ip_packet), 0, NULL, NULL);
if (bytesRecvd == -1) {
perror("Recvfrom error");
fprintf(stderr, "Failed/incomplete receive: ignoring\n");
continue;
}
// Deserialize the message into a packet
bzero(pkt, sizeof(struct ip_packet));
deserializeIpPacket(msg, pkt);
dpkt = (struct packet *)pkt->payload;
printIpPacketInfo(pkt, NULL);
// Check packet type to see if any action needs to be taken
nextSock = malloc(sizeof(struct sockaddr_in));
if (dpkt->type == 'T') {
if (dpkt->len == 0) {
bzero(nextSock, sizeof(struct sockaddr_in));
shouldForward = 1;
nextSock->sin_family = AF_INET;
nextSock->sin_addr.s_addr = htonl(pkt->src);
nextSock->sin_port = htons(pkt->srcPort);
pkt->src = eIpAddr;
pkt->srcPort = emulPort;
}
else {
dpkt->len--;
shouldForward = nextHop(pkt, nextSock);
}
}
else if (dpkt->type == 'S') {
/*if ((pkt->dest == eIpAddr && pkt->destPort == emulPort) || dpkt->len == 0) {
dpkt = createNeighborPkt();
bzero(pkt, sizeof(struct ip_packet));
pkt->length = dpkt->len + HEADER_SIZE;
pkt->priority = 0;
memcpy(pkt->payload, dpkt, sizeof(struct packet));
}*/
if (updateLSP(pkt)) {
floodLSP(sockfd, tmp, pkt);
}
shouldForward = 0;
routesMade = 0;
}
else {
shouldForward = nextHop(pkt, nextSock);
}
// Forward the packet if there is an entry for it
if (shouldForward) {
printf("send packet\n");
//printf("socket is %lu %u", nextSock->sin_addr.s_addr, nextSock->sin_port);
sendIpPacketTo(sockfd, pkt, (struct sockaddr*)nextSock);
free(nextSock);
}
else {
logP(pkt, "No forwarding entry found");
}
// update timespec
long sec = tv->tv_sec - (long)((getTimeMS() - start) / 1000);
long nsec = tv->tv_nsec - (long)(1000000 * ((getTimeMS() - start) % 1000));
if (nsec < 0) {
nsec = 1000000 * 1000 + nsec;
sec--;
}
if (sec < 0 || !numRecv) {
sec = 0;
nsec = 0;
}
tv->tv_sec = sec;
tv->tv_nsec = nsec;
}
if (retval == 0 || routesMade == 0) {
// ------------------------------------------------------------------------
// refresh forward table
printf("retval == 0\n");
if (retval == 0) {
floodLSP(sockfd, tmp, NULL);
}
routesMade = createRoutes(tmp);
int delay = minTime + (rand() % (maxTime - minTime));
tv->tv_sec = (long)delay / 1000;
tv->tv_nsec = (long)(delay % 1000) * 1000000;
}
else {
//printf("Sockfd = %d\n", sockfd);
//printf("tv%d delay=%li s %li us\n", x, tv->tv_sec, tv->tv_nsec);
perrorExit("Select()");
}
}
// Cleanup packets
free(pkt);
free(msg);
}
