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; }