int main ()
{
logFile = new std::ofstream;
(*logFile).open("client_tester.log", std::ios_base::app);
testerAddr.sin_family = AF_INET;
testerAddr.sin_port = (uint16_t) port;
socklen_t addressLength = sizeof(sockaddr_in);
memset(&testerAddr, 0, addressLength);
// create bind and listen on socket
createSocket();
bindSocket();
listenSocket();
// get few commands and print them to log file and stdout?
std::cout << "waiting to accept connection..." << std::endl;
commandSocketFD = accept(testerSocketFD, reinterpret_cast<struct sockaddr *>(&cliAddr), &addressLength);
ssize_t readSize = read(commandSocketFD, buff, MAX_BUFFER_LENGTH);
std::cout << "buff: " << buff << std::endl;
// send responses
}
/* Listen for incomoing connection from the client accpets
* only a maximum of 10 connections */
void setupListenSocket(int port, int *listen_socket) {
struct sockaddr_in address;
createServerAddrStruct(&address, port);
createSocket(listen_socket);
bindSocket(&address, listen_socket);
listen(*listen_socket, MAX_PENDING_CONNECTIONS);
}
/******************************************
* Initialisieren und starten des Servers
*/
void* handleServer(){
#ifdef _DEBUG
fprintf(stderr,"++ handleserver\n");
#endif
char bOK = TRUE;
int sProxyClient= ~0,
sProxyWait = ~0;
struct sockaddr_in saAddress;
struct threadParam *pThreadParam;
if(!generateProxyAddress(&saAddress)) return NULL;
if(!createSocket (&sProxyWait)) return NULL;
if(!bindSocket (&sProxyWait,&saAddress)) return NULL;
if(!listenSocket (&sProxyWait)) return NULL;
//Endlos-schleife fuer accepts
while(1){
bOK=acceptSocket(sProxyWait,&sProxyClient);
if(bOK==TRUE){
#ifdef _DEBUG
fprintf(stderr,"***threadNewClient %d\n",sProxyClient);
#endif
pThreadParam=(struct threadParam*)malloc(sizeof(struct threadParam));
pThreadParam->socketID=sProxyClient;
threadNewClient((void*)pThreadParam);
}
}
closesocket(sProxyWait);
#ifdef _DEBUG
fprintf(stderr,"-- handleserver\n");
#endif
}
int main(){
/*Declares the base file descriptor, and the addresses.*/
int fd;
struct sockaddr_in addr;
struct sockaddr_in cliaddr;
socklen_t cliaddrlen = sizeof(cliaddr);
/*Create file descriptor, define socket, bind socket, listen on fd, create new connection fd, read incoming request into buffer buf.*/
fd = initialiseFd();
addr = defineSocket(addr,8080);
bindSocket(fd,addr);
listenFd(fd,6);
while(1){
int* connfd = malloc(sizeof(int));
pthread_t thrd;
*connfd = initialiseConnFd(fd,cliaddr,cliaddrlen);
pthread_create(&thrd,NULL,readRequest,(void*)connfd);
}
/*close fd*/
close(fd);
return 0;
}
int main(int argc, char *argv[])
{
int receivingSocket, sendingSocket;
u_char ttl;
struct sockaddr_in mcast_group;
struct utsname name;
if ((argc < 3) || (argc > 4)) {
fprintf(stderr, "Usage: %s mcast_group port [ttl]\n", argv[0]);
exit(1);
}
memset(&mcast_group, 0, sizeof(mcast_group));
mcast_group.sin_family = AF_INET;
mcast_group.sin_port = htons((unsigned short int)strtol(argv[2], NULL, 0));
mcast_group.sin_addr.s_addr = inet_addr(argv[1]);
allocateSocket(&sendingSocket);
ttl = (argc == 4) ? strtol(argv[3], NULL, 0) : TTL;
allocateSocket(&receivingSocket);
enableSocketReuse(&receivingSocket);
enableMulticastLoop(&receivingSocket);
bindSocket(&receivingSocket, mcast_group);
joinMulticastGroup(mcast_group.sin_addr, &receivingSocket);
getSystemNodeName(&name);
char buffer[MAXLEN + 1];
FILE *fp;
if (fork() == 0) {
setsid();
chdir("/");
uname(0);
openlog("mcshd", LOG_CONS, LOG_USER);
for (;;) {
memset(buffer, 0, sizeof(buffer));
recvfrom(receivingSocket, buffer, MAXLEN, 0, NULL, NULL);
if (strstr(buffer, "STARTOFCOMMAND: ") != NULL) {
syslog(LOG_INFO, "Received command: %s", buffer);
fp = popen(buffer+16, "r");
if (fp != NULL) {
while (fgets(buffer, MAXLEN, fp) != NULL) {
sendto(sendingSocket, buffer, strlen(buffer)+1, 0, (const struct sockaddr *)&mcast_group, sizeof(mcast_group));
}
snprintf(buffer, MAXLEN, "ENDOFCOMMAND");
sendto(sendingSocket, buffer, strlen(buffer)+1, 0, (const struct sockaddr *)&mcast_group, sizeof(mcast_group));
pclose(fp);
}
}
}
}
exit(0);
}
void monitor() {
sfd = tcpSocket();
if (!sfd) die(1,"Could not allocate socket");
if (reuseSocket(sfd)) die(2,"Failed to reuse socket %d",sfd);
if (bindSocket(sfd, address, htons(port))) die(3,"Failed to bind to %d.%d.%d.%d:%d",IP(address),port);
if (listen(sfd,backlog)) die(4,"Failed to listen on port %d",port);
if (nonblock(sfd)<0) die(5,"Failed to set nonblocking on socket %d", sfd);
debug("Listening on %d.%d.%d.%d:%d",IP(address),port);
}
void Connection::init(int port)
{
int serverFd = createServerSocket();
sockaddr_in address = bindSocket(serverFd, port);
serverSocket = new Socket(-1, serverFd, address);
listen(serverFd, MAX_CONNECTIONS);
}
void bindSocket(int fd, struct sockaddr_in addr){
if (bind(fd, (struct sockaddr *) &addr, sizeof(addr))==-1) {
printf("Error: Binding of socket failed.\nRetrying...\n");
//fprintf(stderr,"Errno %d: %s\n",errno,strerror(errno));
sleep(5);
bindSocket(fd,addr);
return;
}
printf("Bound Socket...\n");
}
HTTPManager::HTTPManager(quint16 port, const QString& documentRoot, HTTPRequestHandler* requestHandler, QObject* parent) :
QTcpServer(parent),
_documentRoot(documentRoot),
_requestHandler(requestHandler),
_port(port)
{
bindSocket();
_isListeningTimer = new QTimer(this);
connect(_isListeningTimer, &QTimer::timeout, this, &HTTPManager::isTcpServerListening);
_isListeningTimer->start(SOCKET_CHECK_INTERVAL_IN_MS);
}
int initServer ( int pPort )
{
// local variables
int socketFile;
// open / bind / listen on socket
socketFile = openSocket ( );
bindSocket ( socketFile, pPort );
listen ( socketFile, NETWORK_BACKLOG_QUEUE );
return socketFile;
}
int main(int argc, char** argv) {
// Check if the port number was provided
if(argc != 2) {
printf("Proper usage: chatserver [port number]");
exit(1);
}
else {
portNo = atoi(argv[1]);
}
// Set up the TCP socket
serverSock = setSocket(&portNo);
// Bind the socket
bindSocket();
while(1) {
// Establish a socket that listens for incoming reqests
listenForReq();
// Accept a client request
isConnected = connectClient();
// allocate memory to send and receive messages
sendBuff = (char*) malloc(512);
recBuff = (char*) malloc(512);
quit = (char*) malloc(10);
strcpy(quit, "\\quit\n");
getClientHandle();
while(1) {
if(receiveMessage() == 0) {
break;
}
if(sendMessage() == 0) {
break;
}
}
}
close(serverSock);
return 0;
}
void setListeningConnection(Connection *conn, const struct sockaddr_in laddr) {
if (getConnectionState(conn) != RUSP_CLOSED)
ERREXIT("Cannot setup listening connection: connection not closed.");
conn->sock.fd = openSocket();
setSocketReusable(conn->sock.fd);
bindSocket(conn->sock.fd, &laddr);
setConnectionState(conn, RUSP_LISTEN);
}
void start()
{
createSocket();
bindSocket();
startListener();
while ( 1 )
{
acceptConnection();
}
}
int main()
{
SocketDescriptor listenfd = 0;
SocketDescriptor connfd = 0;
SocketAddressIn serv_addr;
char sendBuff[1025];
int numrv;
makeSocketTCP(&listenfd);
printf("Socket created\n");
makeSocketAddressAny(&serv_addr, 5200);
printf("Address created\n");
bindSocket(&listenfd, &serv_addr);
printf("Socket bound\n");
if(setListener(&listenfd, 10) == -1)
{
printf("Failed to listen\n");
return -1;
}
printf("Socket listening\n");
tryAcceptClient(&connfd, &listenfd);
printf("Socket accepted client\n");
int dio;
for(dio = 0; dio < 100; ++dio)
{
sprintf(sendBuff, "Message from server %d", dio);
trySendStr(&connfd, sendBuff);
printf("Socket sent message\n");
// sleep(10);
}
closeClient(&connfd);
printf("Socket closed client\n");
close(listenfd);
close(connfd);
printf("Server shutdown\n");
return 0;
}
/* Connect function to initialise the UDP socket
* Returns true if sockt created successfully, false otherwise
*/
bool UDPDataLink::connect() {
if (startWindowsSockets() && //start winsock
setupLocalInterface(port) && //set up local interface
setupDestinationAddress(address, port) && //set up desination address
createSocket() && //create socket
setReuseAddress(true) && //enable address reuse
bindSocket()) { //bind socket
connected = true;
return true;
} else {
connected = false;
return false;
}
}
int main(int argc, char *argv[])
{
int client, listener;
int accepted_bytes;
struct sockaddr_in addr;
struct sockaddr_in clientaddr;
struct hostent* clientInfo;
char accepted_data[1024];
char *clientInfoName;
if (argc < 2)
{
error("ERROR, no parametres provided");
}
listener = createSocket();
bindSocket( listener, &addr, argv[1]);
printf("Starts at port %s", argv[1]);
fflush(stdout);
listen(listener, 1);
while(1)
{
clientaddr.sin_family = AF_INET;
socklen_t client_addr_len = sizeof( clientaddr );
client = accept(listener, (struct sockaddr*)& clientaddr, &client_addr_len );
if( client < 0 )
{
continue;
}
clientInfo = gethostbyaddr( &clientaddr.sin_addr, sizeof ( struct in_addr ) , AF_INET);
clientInfoName = getClientInfo(*clientInfo);
send(client, clientInfoName, strlen( clientInfoName ), 0);
while(1)
{
accepted_bytes = recv(client, accepted_data, 1024, 0);
if( accepted_bytes <= 0) break;
send(client, accepted_data, accepted_bytes, 0);
}
free(clientInfoName);
close(client);
}
close(listener);
return 1;
}
main() {
printf("%d: Avvio del server...\n", getpid());
createSocketStream(&listensdDiServizio);
inizializza_memset(&servaddrDiServizio, SERVICE_PORT);
bindSocket(&listensdDiServizio, &servaddrDiServizio);
listenSocket(&listensdDiServizio, BACKLOG);
int i;
lista_server = malloc(NUMERODISERVERREPLICA*30*sizeof(char));
for(i = 0; i < NUMERODISERVERREPLICA; i++)
lista_server[i] = malloc(30*sizeof(char));
prendi_indirizzi(lista_server); //prelievo e memorizzazione indirizzi da file LISTA_SERVER
//printf("prova funzioni ok %s", lista_server[4]);
//--------------------------------------------------------
pid = fork(); //creo un server figlio
acceptClientDNS(); //che accetta richieste DNS
if(pid > 0) { //il padre è >0 (se è 0 è il figlio)
(void) signal(SIGINT, interrompi); //Gestisce l'interruzione con ctrl-c
printf("%d: Server avviato\n", getpid());
// -1 sta per aspetto qualasiasi figlio che termina, 0 sta per nessuna opzione, rimango bloccato fino a che non muore qualche figlio.
waitpid(-1, &pid, 0);
printf("%d: Il server è stato arrestato per qualche errore!\n", getpid());
exit(0);
}
} //-------------------------end main----------------
int main(int argc, char *argv[])
{
WSADATA wsa;
SOCKET s, new_socket;
char *message;
int done = 1;
char server_reply[200];
printf("\nInitialising Winsock...");
if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
{
printf("Failed. Error Code : %d", WSAGetLastError());
return 1;
}
printf("Initialized.\n");
// Create Socket
createSocket(&s);
// Bind Socket
bindSocket(s, 1456);
//Listen to incoming connections
listen(s, 3);
//Accept and incoming connection
puts("Waiting for incoming connections...");
//Accept connection
acceptConnection(s, &new_socket);
while (done) {
receiveMsg(new_socket, server_reply, 200);
printf("received from client: %s\n", server_reply);
if (!strcmp(server_reply, "bye")){
done = 0;
}
sendMsg(new_socket, server_reply);
}
closesocket(s);
WSACleanup();
return 0;
}
void Connection::connectToWorldServer(const char* worldServerName, const char* port)
{
int serverFd = createWorldServerSocket();
bindSocket(serverFd, GHOST_PORT);
addrinfo hints, *addressInfo;
int status;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
if ((status = getaddrinfo(worldServerName, port, &hints, &addressInfo)) != 0)
error("Error on get server info, %s", gai_strerror(status));
connect(serverFd, addressInfo->ai_addr, addressInfo->ai_addrlen);
worldServerSocket = new Socket(generateId(), serverFd, addressInfo);
}
void AsyncServerSocket::bind(
const std::vector<IPAddress>& ipAddresses,
uint16_t port) {
if (ipAddresses.empty()) {
throw std::invalid_argument("No ip addresses were provided");
}
if (!sockets_.empty()) {
throw std::invalid_argument("Cannot call bind on a AsyncServerSocket "
"that already has a socket.");
}
for (const IPAddress& ipAddress : ipAddresses) {
SocketAddress address(ipAddress.toFullyQualified(), port);
int fd = createSocket(address.getFamily());
bindSocket(fd, address, false);
}
if (sockets_.size() == 0) {
throw std::runtime_error(
"did not bind any async server socket for port and addresses");
}
}
bool CANSocketRaw::start(const char* ifName)
{
LOG_TRACE("");
if(mSocket < 0) {
if(!createSocket()) {
LOG_ERROR("Socket error");
} else {
can_err_mask_t errorMask = 0xFFFFFFFF;
if(!enableCANErrors(errorMask)) {
LOG_ERROR("Socket error");
} else if(!enableTimestamps()) {
LOG_ERROR("Socket error");
} else {
mPoll.fd = mSocket;
mPoll.events = POLLIN | POLLPRI;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
strcpy(ifr.ifr_name, ifName);
if(!locateInterfaceIndex(ifr)) {
LOG_ERROR("Socket error");
stop();
} else {
struct sockaddr_can addr;
memset(&addr, 0, sizeof(addr));
addr.can_family = AF_CAN;
addr.can_ifindex = ifr.ifr_ifindex;
if(!bindSocket(addr)) {
LOG_ERROR("Socket error");
stop();
} else {
return true;
}
}
}
}
}
return false;
}
IOSocket::IOSocket(const socket_type sock_t, const char *host, const int port) {
TRACE_CALL();
socket_t = sock_t;
this->port = port;
memset(&stats, 0x0, sizeof(stats));
sock = ::socket(AF_INET, SOCK_STREAM, 0);
if (sock < 0)
throw("Socket creation error");
switch (socket_t) {
case IOSOCKET_CONNECT_T:
connectToServer(host, port);
break;
case IOSOCKET_LISTEN_T:
bindSocket(port);
break;
default:
throw("Invalid socket type");
}
}
Membership::Membership(bool introducer, int port)
{
logFile.open("logMembership.log");
isIntroducer = introducer;
this->port = port;
leader.active = false;
sockfd = bindSocket(port);
if(isIntroducer){
logFile << "I am the introducer! " << std::endl;
getAdress("Address.add");
}
else{
getAdress("AddrIntro.add");
}
roundLock.lock();
roundId = 0;
roundLock.unlock();
join();
std::thread th3(&Membership::forJoinThread, this);
std::thread th1(&Membership::listeningThread, this);
std::thread th2(&Membership::detectThread, this);
listening.swap(th1);
detecting.swap(th2);
joinThread.swap(th3);
killListeningThread = false;
killDetectingThread = false;
//runLeaderElection();
}
bool UDP_Socket::createSocket(unsigned int port)
{
socketHandle = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (socketHandle < 1)
{
printf("Failed to create the socket\n");
#if PLATFORM == WINDOWS
if (socketHandle == SOCKET_ERROR)
{
printf("Winsock had an error in socket call with code: %d\n", WSAGetLastError());
Sleep(5000);
exit(-1);
}
#endif
return false;
}
if (!bindSocket(port))
{
printf("Unable to bind the socket!\n");
return false;
}
//Handle has been acquired.
return true;
}
void AsyncServerSocket::bind(const SocketAddress& address) {
assert(eventBase_ == nullptr || eventBase_->isInEventBaseThread());
// useExistingSocket() may have been called to initialize socket_ already.
// However, in the normal case we need to create a new socket now.
// Don't set socket_ yet, so that socket_ will remain uninitialized if an
// error occurs.
int fd;
if (sockets_.size() == 0) {
fd = createSocket(address.getFamily());
} else if (sockets_.size() == 1) {
if (address.getFamily() != sockets_[0].addressFamily_) {
throw std::invalid_argument(
"Attempted to bind address to socket with "
"different address family");
}
fd = sockets_[0].socket_;
} else {
throw std::invalid_argument(
"Attempted to bind to multiple fds");
}
bindSocket(fd, address, !sockets_.empty());
}
void main(void){
WSADATA wsaData;
SOCKET listeningSocket;
SOCKET newConnection;
struct sockaddr_in serverAddr, tempAddr;
struct sockaddr_storage clientAddr;
int clientAddrLen;
int port = 5150;
int returnValue, tempAddrLen;
char dataBuffer[666], ansiBuffer[666];
// Инициализация Winsock версии 2.2
if ((returnValue = WSAStartup(MAKEWORD(2, 2), &wsaData)) != 0){
myprintf("WSAStartup ошибка %s\n", encodeWSAGetLastError(returnValue));
return;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Создаём новый TCP сокет для приёма запросов на соединение от клиентов.
listeningSocket = getSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
// Заполняем struct sockaddr_in serverAddr, которая скажет функции bind, что мы хотим
// слушать соединения на всех интерфейсах (INADDR_ANY), используя порт 5150.
// Мы преобразуем порядок байт из системного в сетевой (htons и htonl)
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(port);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
// bind привязывает адресную информацию, определённую в serverAddr к сокету listeningSocket
bindSocket(listeningSocket, serverAddr);
// Сокет пасивный для прослушивания (приёма) TCP соединений. Длина очереди запросов на соединение = 5
setListen(listeningSocket, 5);
tempAddrLen = sizeof(tempAddr);
getsockname(listeningSocket, (struct sockaddr *)&tempAddr, &tempAddrLen);
myprintf("Локальный адрес:%s и порт:%d \n", inet_ntoa(tempAddr.sin_addr), ntohs(tempAddr.sin_port));
tempAddrLen = sizeof(tempAddr);
getpeername(listeningSocket, (struct sockaddr *)&tempAddr, &tempAddrLen);
myprintf("Удалённый адрес:%s и порт:%d \n", inet_ntoa(tempAddr.sin_addr), ntohs(tempAddr.sin_port));
myprintf("Ожидаем соединение на порту %d.\n", port);
// Принимаеи новое соединение, когда оно возникнет
clientAddrLen = sizeof(clientAddr);
clientAddr.__ss_align = 0;
newConnection = accepting(listeningSocket, &clientAddr, clientAddrLen);
getsockname(newConnection, (struct sockaddr *)&tempAddr, &tempAddrLen);
myprintf("Локальный адрес:%s и порт:%d сокета сервера\n", inet_ntoa(tempAddr.sin_addr), ntohs(tempAddr.sin_port));
getpeername(newConnection, (struct sockaddr *)&tempAddr, &tempAddrLen);
myprintf("Удаленный адрес:%s и порт:%d сокета клиента\n", inet_ntoa(tempAddr.sin_addr), ntohs(tempAddr.sin_port));
// Далее мы можем снова ожидать на сокете listeningSocket новые соединения снова вызывая accept
// и/или начать передавать и принимать данные на сокете newConnection.
// Для простоты остановим прослушивание, закрывая сокет listeningSocket.
// Можно начнинать приём и предачу данных на сокете newConnection.
closesocket(listeningSocket);
myprintf("Ждём данные для получения..\n");
/*if ((returnValue = recv(newConnection, dataBuffer, sizeof(dataBuffer), 0)) == SOCKET_ERROR){
myprintf("Ошибка recv %s\n", encodeWSAGetLastError(WSAGetLastError()));
closesocket(newConnection);
WSACleanup();
exit(1);
}*/
if ((returnValue = recv(newConnection, u1.c, sizeof(u1), 0)) == SOCKET_ERROR){
myprintf("Ошибка recv %s\n", encodeWSAGetLastError(WSAGetLastError()));
closesocket(newConnection);
WSACleanup();
exit(1);
}
// Делаем из полученных данных строку на С
//dataBuffer[returnValue] = '\0';
//OemToChar(dataBuffer, ansiBuffer);
int offset = 0, result1=1, result2=1;
printf("%e", u1.d);
//int operationIndex = switchOperation(ansiBuffer, &offset);
/*if (operationIndex == -1){
myprintf("Получено %d байтов в сообщении %s\n", returnValue, ansiBuffer);
myprintf("\nОбратная передача сообщения...\n");
returnValue = sendMessage(newConnection, ansiBuffer, strlen(ansiBuffer));
myprintf("Передано %d байтов.\n", returnValue);
}
else{
BOOL flagAnswer = FALSE;
int answer = 0;
myprintf("%s\n", ansiBuffer);
switch (operationIndex)
{
case 0:
myprintf("Принята команда <qs> на закрытие...\n");
break;
case 1:
if (getNumber(ansiBuffer, offset, &result1, &result2))
flagAnswer = TRUE;
answer = result1 + result2;
myprintf("%d\n", answer);
break;
case 2:
if (getNumber(ansiBuffer, offset, &result1, &result2))
flagAnswer = TRUE;
answer = result1 - result2;
myprintf("%d\n", answer);
break;
case 3:
if (getNumber(ansiBuffer, offset, &result1, &result2))
flagAnswer = TRUE;
answer = result1 * result2;
myprintf("%d\n", answer);
break;
case 4:
if (getNumber(ansiBuffer, offset, &result1, &result2))
if (result2 != 0){
flagAnswer = TRUE;
answer = result1 / result2;
myprintf("%d\n", answer);
}else myprintf("Деление на 0!\n");
break;
default:
break;
}
if (flagAnswer){
myprintf("\nОбратная передача сообщения...\n");
char temp[666];
_itoa_s(answer, temp, 666, 10);
returnValue = sendMessage(newConnection, temp, strlen(temp));
myprintf("Передано %d байтов.\n", returnValue);
}
}*/
myprintf("Закрываем соединение с клиентом.\n");
closesocket(newConnection);
WSACleanup();
system("pause");
}
//Begins the connection
void establishConnection(char *type, int *replay, char *ip) {
//Ensure players cannot leave
signal(SIGINT, leaveError);
//Server variables
struct sockaddr_in dataAddr;
int clientSocket;
struct sockaddr_in myAddr;
int i, addrSize;
char buffer[50];
//Game variables
char o_phrase[40];
char my_phrase[40];
char h_o_phrase[40];
char h_my_phrase[40];
char board[1000];
board[0] = '\0';
char guess[80];
guess[0] = '\0';
int bytesRcv;
int win = 0;
//Server connect
if (strcmp(type, "server") == 0) {
setupSocket(&myListenSocket, &myAddr, type, "");
bindSocket(&myListenSocket, &myAddr);
waitForConnection(&myListenSocket, &myAddr, &clientSocket, &dataAddr); //fix
}
//Client connect
if (strcmp(type, "client") == 0) {
setupSocket(&clientSocket, &dataAddr, type, ip);
connectAsClient(&clientSocket, &dataAddr);
}
//Loop while the game is supposed to be played again
while (*replay == 1) {
//Creates the player's phrase, hides it and stores the unhidden phrase in the buffer
game_createPhrase(my_phrase);
game_toHidden(my_phrase, h_my_phrase);
strcpy(buffer, my_phrase);
//Send the phrase to the other player and wait for them to send back
send(clientSocket, buffer, strlen(buffer), 0);
fprintf(stdout, "Waiting for your opponent to create their secret phrase...\n");
//Store what was sent back in the opponent's phrase variable
bytesRcv = recv(clientSocket, buffer, sizeof(buffer), 0);
buffer[bytesRcv] = '\0';
strcpy(o_phrase, buffer);
//Hide their phrase and create the board to print on screen
game_toHidden(o_phrase, h_o_phrase);
game_makeBoard(h_my_phrase, h_o_phrase, board);
//Show the player their own phrase
fprintf(stdout, "Your phrase: %s\n\n", my_phrase);
//Counter to make the client go first initially
i = 0;
//Game loop
while (1) {
//Ensures that the client goes first
if (i > 0 || strcmp(type, "server") == 0) {
//Wait for opponent to guess and store guess in buffer
fprintf(stdout, "Waiting for your opponent's guess...\n");
bytesRcv = recv(clientSocket, buffer, sizeof(buffer), 0);
buffer[bytesRcv] = '\0';
strcpy(guess, buffer);
//Compare guess with the actual phrase and check for win condition (1 = win, 0 = no win)
game_guess(guess, my_phrase, h_my_phrase, &win);
if (win == 1) {
win = 0;
//Wait to see if the opponent wants to play again
fprintf(stdout, "Your opponent has won. Please wait while he decides he wants to play again...\n");
bytesRcv = recv(clientSocket, buffer, sizeof(buffer), 0);
buffer[bytesRcv] = '\0';
//If opponent sends back "left", we need to do some things depending on if the opponent was the host or not
if (strcmp(buffer, "left") == 0) {
fprintf(stdout, "Your opponent left!\n");
//If you were the server and lost
if (strcmp(type, "server") == 0) {
//Re-setup the socket and listen for a new connection
setupSocket(&clientSocket, &myAddr, type, "");
waitForConnection(&myListenSocket, &myAddr, &clientSocket, &dataAddr);
i = 0;
break;
}
//Close the client socket, change player type to server and listen for a new connection
else {
close(clientSocket);
strcpy(type, "server");
setupSocket(&myListenSocket, &dataAddr, type, "");
waitForConnection(&clientSocket, &dataAddr, &myListenSocket, &myAddr); //TODO fix
break;
}
*replay = -1;
return;
}
//If they didn't send back "left", then they want to play again
//So simply break out of the game loop to start a new game with new phrases
else {
system("clear");
fprintf(stdout, "Your opponent wants to play again, let's go!\n");
break;
}
}
//Update the game board
game_makeBoard(h_my_phrase, h_o_phrase, board);
fprintf(stdout, "Your phrase: %s\n\n", my_phrase);
fprintf(stdout, "Your opponent guessed: %s\n", guess);
}
//Ask for user input
fprintf(stdout, "Guess a letter or the entire phrase.\n");
fgets(guess, sizeof(guess), stdin);
guess[strlen(guess)-1] = '\0';
//Compare guess with the actual phrase and check for win condition (1 = win, 0 = no win), then update the game baord
game_guess(guess, o_phrase, h_o_phrase, &win);
game_makeBoard(h_my_phrase, h_o_phrase, board);
fprintf(stdout, "Your phrase: %s\n\n", my_phrase);
//Send the opponent what the user guessed
strcpy(buffer, guess);
send(clientSocket, buffer, strlen(buffer), 0);
//If the user won, then see if they want to play again
if (win == 1) {
game_playAgain(replay);
//Wants to play again
if (*replay == 1) {
strcpy(buffer, "stay");
send(clientSocket, buffer, strlen(buffer), 0);
win = 0;
break;
}
//Doesn't want to play again
else {
strcpy(buffer, "left");
send(clientSocket, buffer, strlen(buffer), 0);
//Reset SIGINT to its default functionality
signal(SIGINT, SIG_DFL);
return;
}
}
//Increment i allowing for the server to have a guess
i++;
}
}
//Close the final listen socket (never occurs)
close(myListenSocket);
}
static void createArrayIp(int pConnectionsCounter)
{
bindSocket();
ips = (char**)malloc(sizeof(char*) * pConnectionsCounter);
ports = (int*)malloc(sizeof(int) * pConnectionsCounter);
}
/**
* Create socket and "connect" it to target
* allocates and sets options.targetip
*
* return fd, or <0 (-errno) on error
*/
static int
setupSocket()
{
int fd = -1;
int err = 0;
struct addrinfo *addrs = 0;
struct addrinfo hints;
if (options.verbose > 2) {
fprintf(stderr, "%s: setupSocket(%s)\n",
argv0, options.target);
}
if (!(options.targetip = malloc(NI_MAXHOST))) {
err = errno;
fprintf(stderr, "%s: malloc(NI_MAXHOST): %s\n",
argv0, strerror(err));
goto errout;
}
/* resolve to sockaddr */
memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_ADDRCONFIG;
hints.ai_family = options.af;
hints.ai_socktype = SOCK_DGRAM;
if (0 > (err = getaddrinfo(options.target,
options.port,
&hints,
&addrs))) {
int gai_err;
gai_err = err;
if (gai_err == EAI_SYSTEM) {
err = errno;
} else {
err = EINVAL;
}
if (gai_err == EAI_NONAME) {
fprintf(stderr, "%s: unknown host %s\n",
argv0, options.target);
err = EINVAL;
goto errout;
}
fprintf(stderr, "%s: getaddrinfo(%s): %s\n",
argv0, options.target, gai_strerror(gai_err));
goto errout;
}
/* get ip address string options.targetip */
if ((err = getnameinfo(addrs->ai_addr,
addrs->ai_addrlen,
options.targetip,
NI_MAXHOST,
NULL, 0,
NI_NUMERICHOST))) {
int gai_err;
gai_err = err;
if (gai_err == EAI_SYSTEM) {
err = errno;
} else {
err = EINVAL;
}
fprintf(stderr, "%s: getnameinfo(): %s\n",
argv0, gai_strerror(gai_err));
goto errout;
}
if (options.verbose > 1) {
fprintf(stderr, "%s: target=<%s> targetip=<%s>\n",
argv0,
options.target,
options.targetip);
}
/* socket() */
if (0 > (fd = socket(addrs->ai_family,
addrs->ai_socktype,
addrs->ai_protocol))) {
err = errno;
fprintf(stderr, "%s: socket(%d, %d, %d): %s\n",
argv0,
addrs->ai_family,
addrs->ai_socktype,
addrs->ai_protocol,
strerror(err));
goto errout;
}
errInspectionInit(fd, addrs);
bindSocket(fd, addrs);
if (addrs->ai_family == AF_INET) {
int on = 1;
if (options.ttl > 0) {
if (setsockopt(fd,
SOL_IP,
IP_TTL,
&options.ttl,
sizeof(options.ttl))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IP, IP_TTL, "
"%d): %s\n", argv0, fd, options.ttl,
strerror(errno));
}
}
if (options.tos >= 0) {
if (setsockopt(fd,
SOL_IP,
IP_TOS,
&options.tos,
sizeof(options.tos))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IP, IP_TOS, "
"%d): %s\n", argv0, fd, options.tos,
strerror(errno));
}
}
if (setsockopt(fd,
SOL_IP,
IP_RECVTTL,
&on,
sizeof(on))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IP, "
"IP_RECVTTL, on): %s\n",
argv0, fd, strerror(errno));
}
#ifdef IP_RECVTOS
if (setsockopt(fd,
SOL_IP,
IP_RECVTOS,
&on,
sizeof(on))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IP, "
"IP_RECVTOS, on): %s\n",
argv0, fd, strerror(errno));
}
#endif
}
if (addrs->ai_family == AF_INET6) {
int on = 1;
if (options.ttl > 0) {
#ifndef IPV6_HOPLIMIT
fprintf(stderr,
"%s: Setting hoplimit on IPv6 "
"is not supported on your OS\n", argv0);
#else
if (setsockopt(fd,
SOL_IPV6,
IPV6_HOPLIMIT,
&options.ttl,
sizeof(options.ttl))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IPV6, "
"IPV6_HOPLIMIT, %d): %s\n",
argv0, fd, options.ttl,
strerror(errno));
}
#endif
}
if (options.tos >= 0) {
#ifndef IPV6_TCLASS
fprintf(stderr,
"%s: Setting traffic class on IPv6 "
"is not supported on your OS\n", argv0);
#else
if (setsockopt(fd,
SOL_IPV6,
IPV6_TCLASS,
&options.tos,
sizeof(options.tos))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IPV6, "
"IPV6_TCLASS, %d): %s\n",
argv0, fd, options.tos,
strerror(errno));
}
#endif
}
#ifdef IPV6_RECVHOPLIMIT
if (setsockopt(fd,
SOL_IPV6,
IPV6_RECVHOPLIMIT,
&on,
sizeof(on))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IPV6, "
"IPV6_RECVHOPLIMIT, on): %s\n",
argv0, fd, strerror(errno));
}
#endif
#ifdef IPV6_RECVTCLASS
if (setsockopt(fd,
SOL_IPV6,
IPV6_RECVTCLASS,
&on,
sizeof(on))) {
fprintf(stderr,
"%s: setsockopt(%d, SOL_IPV6, "
"IPV6_RECVTCLASS, on): %s\n",
argv0, fd, strerror(errno));
}
#endif
}
/* connect() */
if (connect(fd,
addrs->ai_addr,
addrs->ai_addrlen)) {
err = errno;
fprintf(stderr, "%s: connect(%d, ...): %s\n",
argv0, fd, strerror(err));
close(fd);
goto errout;
}
freeaddrinfo(addrs);
return fd;
errout:
if (addrs) {
freeaddrinfo(addrs);
addrs = 0;
}
if (options.targetip) {
free(options.targetip);
options.targetip = 0;
}
if (err == 0) {
err = -EINVAL;
}
if (fd >= 0) {
close(fd);
fd = -1;
}
if (err > 0) {
err = -err;
}
return err;
}
int natblaster_connect(ip_t helper_ip, port_t helper_port, ip_t peer_ip,
port_t peer_port, ip_t buddy_ext_ip, ip_t buddy_int_ip,
port_t buddy_int_port, char *device, flag_t random) {
peer_conn_info_t info;
/* the return type is "int", but I return "errorcode"s because I know that
* they are the same real type and that all the errorcodes are negative.
* This makes debugging easier. */
/* first find a device if needed */
if (device==NULL)
CHECK_FAILED(findDevice(&device),ERROR_NO_DEV_FOUND);
DEBUG(DBG_VERBOSE, "VERBOSE:connecting to Buddy....%s:%uint\n",
DBG_IP(buddy_int_ip), DBG_PORT(buddy_int_port));
DEBUG(DBG_VERBOSE," %sext\n", DBG_IP(buddy_ext_ip));
DEBUG(DBG_VERBOSE, "VERBOSE:from local address.....%s:%u\n",
DBG_IP(peer_ip), DBG_PORT(peer_port));
DEBUG(DBG_VERBOSE, "VERBOSE:with helper............%s:%u\n",
DBG_IP(helper_ip), DBG_PORT(helper_port));
DEBUG(DBG_VERBOSE, "VERBOSE:using Device...........%s\n",
device);
DEBUG(DBG_VERBOSE, "VERBOSE: this peer is %srandom\n",
(random==FLAG_SET ? "" : "not "));
/* now put the info in a conn_info structure */
info.helper.ip = helper_ip;
info.helper.port = helper_port;
info.peer.ip = peer_ip;
info.peer.port = peer_port;
info.peer.set = FLAG_SET;
info.buddy.int_ip = buddy_int_ip;
info.buddy.int_port = buddy_int_port;
info.buddy.ext_ip = buddy_ext_ip;
info.buddy.identifier = FLAG_SET;
info.buddy.ext_port = PORT_UNKNOWN;
info.buddy.ext_port_set = FLAG_UNSET;
info.socks.helper = SOCKET_UNKNOWN;
info.socks.helper_pred = SOCKET_UNKNOWN;
info.socks.buddy = SOCKET_UNKNOWN;
info.device = device;
info.direct_conn_status = FLAG_UNSET;
info.bday.stop_synack_find = FLAG_UNSET;
/* buddy sock gets filled in below */
/* bind the desired port for a connection to buddy */
CHECK_FAILED(bindSocket(info.peer.port,&info.socks.buddy),ERROR_1);
/* bind socket for helper connection (2 before buddy port); */
if (random==FLAG_UNSET)
info.helper_conn.persistent_port = PORT_ADD(peer_port,-2);
else /* bind a "random" port (not the conventional port) */
info.helper_conn.persistent_port = PORT_ADD(peer_port,-3);
CHECK_FAILED(bindSocket(info.helper_conn.persistent_port,
&info.socks.helper),ERROR_2);
/* bind port for second helper connection */
info.helper_conn.prediction_port = PORT_ADD(peer_port,-1);
CHECK_FAILED(bindSocket(info.helper_conn.prediction_port,
&info.socks.helper_pred),ERROR_3);
if (FAILED(peer_fsm_start(&info))) {
/* close the sockets */
close(info.socks.helper);
close(info.socks.helper_pred);
close(info.socks.buddy);
return ERROR_4;
}
/* close helper sockets */
close(info.socks.helper);
close(info.socks.helper_pred);
return info.socks.buddy;
}
