int send_probes(struct routes* route_list, struct probeList* probe_list) {
struct probereq_packet* probereq_pack = malloc(sizeof(struct probereq_packet));
probereq_pack->ID = getTime();
struct route* ptr = route_list->head;
struct probeList *tmp;
while(ptr != NULL){
if(sendPacketToSock((void*)probereq_pack,ptr->socket_fd) == -1){
}
struct probeList* new_probe = malloc(sizeof(struct probeList));
new_probe->link = ptr->link;
new_probe->ID = probereq_pack->ID;
tmp = probe_list;
new_probe->next = tmp;
probe_list = new_probe;
ptr = ptr->next;
}
return 1;
}
void
sendPacket(int playerid, struct NetPacket* pkt)
{
if ( (playerid < JNB_MAX_PLAYERS) && (playerid >= 0)) {
if ((player[playerid].enabled) && (playerid != client_player_num)) {
sendPacketToSock(net_info[playerid].sock, pkt);
}
}
}
/* Send a linkstate packet to a socket
* param socket_fd: socket to send to
* param membership list: list of linkstates to create
* a linkstate packet from and send
* return: Number of neighbors sent
*/
int send_linkstate(int socket_fd, struct LinkStateNode* link_list) {
struct linkstate_packet lstate_pack;
getLocalAddrInfo(socket_fd, &lstate_pack.source);
lstate_pack.linkstate_head = link_list;
/* Send linkstate packet to socket */
sendPacketToSock(&lstate_pack, socket_fd);
//TODO: Figure out how to lock here and send
}
/* Send a packet to everybody in the route list
* param route_list: the ptr to the head of the list of routes
* param packet: packet to send to everybody in route_list
* return: -1 if there is an error, 0 otherwise
*/
int broadcast(struct routes* route_list, void* packet){
struct route* ptr = route_list->head;
while(ptr != NULL){
if(sendPacketToSock(packet, ptr->socket_fd) == -1){
return -1;
}
ptr = ptr->next;
}
return 0;
}
void
tellServerNewPosition()
{
struct NetPacket pkt;
pkt.cmd = NETCMD_POSITION;
pkt.arg = client_player_num;
pkt.arg2 = player[client_player_num].x;
pkt.arg3 = player[client_player_num].y;
if (is_server) {
sendPacketToAll(&pkt);
} else {
sendPacketToSock(sock, &pkt);
}
}
void
tellServerGoodbye()
{
struct NetPacket pkt;
if (!buggered_off) {
buggered_off = 1;
pkt.cmd = NETCMD_BYE;
pkt.arg = client_player_num;
pkt.arg2 = 0;
pkt.arg3 = 0;
pkt.arg4 = 0;
sendPacketToSock(sock, &pkt);
}
}
void tellServerPlayerMoved(int playerid, int movement_type, int newval)
{
NetPacket pkt;
pkt.cmd = NETCMD_MOVE;
pkt.arg = playerid;
pkt.arg2 = ( ((movement_type & 0xFF) << 16) | ((newval & 0xFF) << 0) );
pkt.arg3 = player[playerid].x;
pkt.arg4 = player[playerid].y;
if (is_server) {
processMovePacket(&pkt);
#ifdef USE_NET
if (is_net)
sendPacketToAll(&pkt);
} else {
sendPacketToSock(sock, &pkt);
#endif /* USE_NET */
}
}
void connectToPeers(struct peerlist* plist) {
struct peerlist* ptr = plist;
struct peerlist* tmp;
while(ptr != NULL) {
int connection_fd = connectTo(ptr->hostname, ptr->port);
/* Send 1 record linkstate packet,
* with RTT of 1 and ID of current time */
struct LinkStateNode self_lstate;
self_lstate.ID = getTime();
self_lstate.avg_RTT = 1;
self_lstate.next = NULL;
struct AddressInfo local, remote;
if(getLocalAddrInfo(connection_fd, &local) == -1){
fprintf(stderr, "Could not get local info. Error Code: %d", connection_fd);
exit(EXIT_FAILURE);
}
if(getRemoteAddrInfo(connection_fd, &remote) == -1){
fprintf(stderr, "Could not get remote info. Error Code: %d", connection_fd);
exit(EXIT_FAILURE);
}
self_lstate.local = local;
self_lstate.remote = remote;
/* Send 1 record linkstate packet of end peer */
sendPacketToSock((void*)&self_lstate,connection_fd);
tmp = ptr;
ptr = ptr->next;
free(tmp);
}
}
void newConnHandler(void* newConnection) {
int remote_fd = (int) newConnection;
struct AddressInfo localInfo;
getLocalAddrInfo(remote_fd, &localInfo);
struct AddressInfo remoteInfo;
getRemoteAddrInfo(remote_fd, &remoteInfo);
/*Check if member*/
if(!checkForMember(members, &localInfo, &remoteInfo)) {
void *packet;
/*Get LinkStateNode*/
uint16_t headerType = readPacketFromSock(remote_fd, &packet);
if(headerType == PACKET_TYPE_LINKSTATE &&
((struct linkstate_packet *)packet)->num_neighbors == 1) {
/*Received proper linkstate packet with only 1 neighbor: us!*/
struct linkstate_packet* link_pack = (struct linkstate_packet*)packet;
/* Manipulate dest to include your mac address TODO getlocalinfo */
struct AddressInfo dest;
getLocalAddrInfo(remote_fd, &dest);
link_pack->linkstate_head->remote= dest;
/* Reverse local & dest and add to membership list TODO */
/* Reverse local & dest and add to membership list TODO */
/* Reverse local & dest and add to membership list TODO */
struct LinkStateNode* linkstate = malloc(sizeof(struct LinkStateNode));
linkstate->local = dest;
linkstate->remote = link_pack->linkstate_head->local;
linkstate->ID = getTime();
linkstate->avg_RTT = 1;
linkstate->next = NULL;
/* Add client to Membership list */
addMemberToList(members, linkstate);
/* Send the unreversed but manipulated lstate pack back, but change source to you TODO */
link_pack->source = link_pack->linkstate_head->local;
sendPacketToSock(link_pack, remote_fd);
}
else {
printf("New connection sent packet other than linkstate. Dropping...\n");
close(remote_fd);
}
}
while(globalStatus) {
void* packet;
uint16_t headerType = readPacketFromSock(remote_fd, &packet);
if(dissectPacket(packet, remote_fd) < 0) {
printf("ERROR: Couldn't read packet properly..\n");
break;
}
}
}
