int main(int argc, char* argv[]) {
struct sockaddr_in serverAddress; //Contains info for server address
char *buffer = (char*) malloc(1024); //buffer for sending commands
FILE* cmds; //file pointer to commands.txt
unsigned int sleeptime;
int sock; //socket
if(argc > 2) {
err_n_die("Arguments: ./program <ip address>");
}
//create socket
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
memset(&serverAddress, 0, sizeof(serverAddress));
serverAddress.sin_family = AF_INET;
serverAddress.sin_port = htons(5000);
if(inet_pton(AF_INET, argv[1], &serverAddress.sin_addr.s_addr) == -1) {
err_n_die("inet_pton() failed\n");
}
//read commands from text file.
cmds = fopen("commands.txt", "r");
size_t len = 0;
while(getLines(&buffer, cmds,&len) != -1) {
//Get sleep time
if(strstr(buffer, "sleep") != NULL){
//Get ready for bed.
int i = 0;
for(i = 0; i < strlen(buffer); i++) {
if((int)buffer[i] < 10) {
//good night
sleeptime = (unsigned int)buffer[i];
sleep(sleeptime);
break;
} //if
} //for
} //if
//send regular command
else {
if(sendto(sock, buffer, MAX, 0, (struct sockaddr *)&serverAddress, sizeof(serverAddress)) < 0) {
err_n_die("sendto() failed\n");
} //if
} //else
//Block until we get response
getResponse();
} //while
//TODO: Receive data and save data. infinite loop?
free(buffer);
fclose(cmds);
return 0;
} //main
int main(int argc, char *argv[]){
if (argc != 2){
err_n_die("Parameters: <Port>");
}
in_port_t servPort = atoi(argv[1]);
// create socket
int serverSocket;
serverSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(serverSocket < 0){
err_n_die("Could not create socket");
}
// local address struct
struct sockaddr_in servAddr;
memset(&servAddr,0,sizeof(servAddr));
servAddr.sin_family = AF_INET;
servAddr.sin_addr.s_addr = htonl(INADDR_ANY);
servAddr.sin_port = htons(servPort);
// bind and listen
if(bind(serverSocket,(struct sockaddr*) &servAddr,sizeof(servAddr)) < 0){
err_n_die("Could not bind ServerSocket");
}
if (listen(serverSocket, 5) < 0){
err_n_die("Could not listen");
}
while(1){
//
struct sockaddr_in clntAddr;
socklen_t clntAddrLen = sizeof(clntAddr);
int client = accept(serverSocket,(struct sockaddr *) &clntAddr,&clntAddrLen);
if(client < 0){
err_n_die("Could not accept connection");
}
char clientName[INET_ADDRSTRLEN];
if(inet_ntop(AF_INET, &clntAddr.sin_addr.s_addr,clientName,sizeof(clientName)) != NULL){
printf("Connected to client %s on port %d \n",clientName, ntohs(clntAddr.sin_port));
}
else {
printf("Unable to get client address");
}
handleClient(client);
}
}
int main(int argc, char*argv[]){
if (argc != 4){
err_n_die("Usage: <ip> <serverport> <message>");
}
char * servIP = argv[1];
char * message = argv[3];
in_port_t servPort = atoi(argv[2]);
int sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(sock < 0 ){
err_n_die("could not create socket");
}
struct sockaddr_in servAddr;
memset(&servAddr,0,sizeof(servAddr));
servAddr.sin_family = AF_INET;
int rtnVal = inet_pton(AF_INET,servIP,&servAddr.sin_addr.s_addr);
if (rtnVal < 0){
err_n_die("Could not convert IP address");
}
servAddr.sin_port = htons(servPort);
if(connect(sock,(struct sockaddr*) &servAddr,sizeof(servAddr)) < 0){
err_n_die("Could not connect");
}
size_t messageLength = strlen(message);
ssize_t bytesSent = send(sock,message,messageLength,0);
if (bytesSent <0 || bytesSent != messageLength){
err_n_die("Could not send message");
}
printf("Message sent waiting for reply\n");
char buffer[1024];
ssize_t bytesRecieved = recv(sock,buffer,1024,0);
strcat(buffer,"\0");
printf("%s\n",buffer);
close(sock);
exit(0);
}
void handleClient(int socket){
char buffer[1024];
// recieve message
ssize_t bytesReceived = recv(socket, buffer,1024,0);
if(bytesReceived < 0){
err_n_die("Receive failed");
}
strcat(buffer,"\0");
printf("%s\n",buffer);
ssize_t numBytesSent = send(socket, buffer, bytesReceived,0);
printf("Echoed %ld bytes\n",numBytesSent);
close(socket);
}
int main(int argc, char **argv)
{
int listenfd, connfd, n;
struct sockaddr_in servaddr;
char buff[MAXLINE+1];
char recvline[MAXLINE+1];
time_t ticks;
if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0 )
err_n_die("socket error.");
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERVER_PORT); /* server port */
if ((bind(listenfd, (SA *) &servaddr, sizeof(servaddr))) < 0)
err_n_die("bind error.");
if ((listen(listenfd, LISTENQ)) < 0)
err_n_die("listen error.");
for ( ; ; ) {
//accept blocks until an incoming connection arrives
//it returns a "file descriptor" to the connection
printf("waiting for a connection...");
fflush(stdout);
connfd = accept(listenfd, (SA *) NULL, NULL);
printf("got one! \n");
if (connfd < 0)
{
#ifdef EPROTO
if (errno != EPROTO || errno != ECONNABORTED)
#else
if (errno != ECONNABORTED)
#endif
{
continue; //skip this round of the for loop
} else {
err_n_die("accept error that wasn't an aborted connection.");
}
}
//Now read the client's message.
while ( (n = read(connfd, recvline, MAXLINE)) > 0)
{
recvline[n] = 0; /* null terminate */
if (fputs(recvline, stdout) == EOF)
err_n_die("fputs error");
//detect the end of the message.
if (recvline[n-1] == '\n')
{
break;
}
}
if (n < 0)
err_n_die("read error");
//now send a response.
ticks = time(NULL);
snprintf(buff, sizeof(buff), "Thanks. Recved at (%.24s)\r\n", ctime(&ticks));
//note: normally, you may want to check the results from write and close
//in case errors occur. For now, I'm ignoring them.
write(connfd, buff, strlen(buff));
close(connfd);
}
}
int main(int argc, char*argv[]){
int sock;
int n; // number of chars
struct sockaddr_in serverAddr;
struct sockaddr_in clientAddr;
unsigned int clientAddrLength;
uint16_t serverPort;
timesGuessedCorrectly = 0;
timesGuessed = 0;
// parse command line inputs
if(argc < 3 || argc > 4){
printf("Usage: <port> <number of characters> \n");
exit(1);
}
serverPort = atoi(argv[1]);
n = atoi(argv[2]);
if(n > 8){
printf("Number of characters exceeds maximum size, Rounding to 8\n");
}
char password[n+1];
if(argc == 4){
strcpy(password,argv[3]);
}else{
generateRandomPassword(n,password);
password[n] = '\0';
}
printf("password = %s \n",password);
// handle signal
signal(SIGINT,handleInterupt);
//initialize incoming list
root = malloc(sizeof(root));
strcpy(root->IP,"root");
struct linkedAddress *current;
current = root;
current->next = NULL;
// create and bind sockets
if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
err_n_die("Could not open socket\n");
}
memset(&serverAddr,0,sizeof(serverAddr));
serverAddr.sin_family = AF_INET;
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddr.sin_port = htons(serverPort);
if(bind(sock,(struct sockaddr *) &serverAddr,sizeof(serverAddr)) < 0){
err_n_die("Could not bind to socket\n");
}
int returnCode;
for(;;){
clientAddrLength = sizeof(clientAddr);
int recvMsgSize,sentMsgSize;
char buffer[20];
// recv message from server
if((recvMsgSize = recvfrom(sock,buffer,20,0,(struct sockaddr*) &clientAddr,
&clientAddrLength)) < 0) {
err_n_die("Could not receive message\n");
}
// store IP in linked list
char IP[INET_ADDRSTRLEN+1];
inet_ntop(AF_INET, &(clientAddr.sin_addr),IP,INET_ADDRSTRLEN+1);
if(IP != NULL){
addToList(IP);
} else{
printf("IP address for client can not be resolved\n");
}
// if password is correct regenerate new password
if(strcmp(buffer,password)== 0){
returnCode = 0;
generateRandomPassword(n,password);
password[n] = '\0';
timesGuessedCorrectly++;
}else{
returnCode = 1;
}
timesGuessed++;
// send return code
if((sentMsgSize = sendto(sock,&returnCode,20,0,(struct sockaddr*) &clientAddr,
clientAddrLength)) < 0){
err_n_die("Could not send message");
}
}
}
