// compile: gcc socketTCPClient.c -o socketTCPClient.out
// usage  : ./socketTCPClient.out port
// Doesn't send anything, just connects and prints out the response from the server

#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <arpa/inet.h>

int main(int argc, char *argv[]){
        int sockfd = 0, n = 0, portno;
        char recvBuff[1025];
        struct sockaddr_in serv_addr;

        memset(recvBuff, '0', sizeof(recvBuff));
        if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
                printf("socket error\n");
                exit(EXIT_FAILURE);
        }

        serv_addr.sin_family = AF_INET;
        portno = atoi(argv[1]);
        serv_addr.sin_port = htons(portno);
        serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

        if(connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) < 0){
                printf("connect error\n");
                exit(EXIT_FAILURE);
        }

        while((n = read(sockfd, recvBuff, sizeof(recvBuff)-1)) > 0){
                recvBuff[n] = 0;
                if (fputs(recvBuff, stdout) == EOF)
                {
                        printf("fputs error\n");
                }
        }

        if(n < 0){
                printf("read error\n");
        }

        return 0;
}

#include <stdio.h>
#include <assert.h>
#include <signal.h>

void myHandler(int iSig) {
  printf("In myHandler with argument %d\n", iSig);
}
int main() {
  void( * pfRet)(int) = signal(SIGINT, myHandler);
  assert(pfRet != SIG_ERR);
  printf("Entering an infinite loop\n");
  while (1) {
    printf(".");
  }
  return 0; // use CTRL+\ to exit
}

#include <stdio.h>
#include <stdlib.h>

calculate(a, b)
int a;
int b;
{
        printf("%d", a+b);
}

main(argc, argv)
int argc;
char** argv;
{
        if(argc < 3){
                return 0;
        }
        calculate(atoi(argv[1]), atoi(argv[2]));
}

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
  pid_t pid; /* could be int */
  int i;
  pid = fork();
  printf("PID=%d\n", pid);
  if (pid > 0) {
    /* parent */
    for (i = 0; i < 10; i++)
      printf("\t\t\tPARENT %d\n", i);
  } else {
    /* child */
    for (i = 0; i < 10; i++)
      printf("CHILD %d\n", i);
  }
  return 0;
}

// Client side implementation of UDP client-server model
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define PORT 8008
#define MAXLINE 1024

// Driver code
int main() {
        char buffer[MAXLINE];
        struct sockaddr_in servaddr;

        // Creating socket file descriptor

        int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if ( sockfd < 0 ) {
                perror("socket creation failed");
                exit(EXIT_FAILURE);
        }

        struct timeval timeout;
        timeout.tv_sec = 1; //Wait 1 second
        timeout.tv_usec = 0;

        if (setsockopt (sockfd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof timeout) < 0) perror("setsockopt failed\n");

        if (setsockopt (sockfd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof timeout) < 0) perror("setsockopt failed\n");

        memset(&servaddr, 0, sizeof(servaddr));

        // Filling server information
        servaddr.sin_family = AF_INET;
        servaddr.sin_port = htons(PORT);
        servaddr.sin_addr.s_addr = inet_addr("192.168.4.65");

        for(int i = 0; i < 10; ++i){
                char* message = "PING";
                int sendStatus = sendto(sockfd, (const char *)message, strlen(message), MSG_CONFIRM, (const struct sockaddr *) &servaddr, sizeof(servaddr));
                if(sendStatus >= 0){
                        printf("Sent PING\n");
                }else{
                        printf("Send failed\n");
                        continue;
                }

                int len = sizeof(struct sockaddr_in);
                int bytesRecieved = recvfrom(sockfd, (char *)buffer, MAXLINE, MSG_WAITALL, (struct sockaddr *) &servaddr, &len); //We can reuse servaddr because the port the server sends messages from is the same one we send to
                if(bytesRecieved >= 0){
                        buffer[bytesRecieved] = '\0';
                        printf("Recieved %s\n", buffer);
                }else{
                        printf("Recieved nothing: Packet Dropped\n", buffer);
                }
        }

        close(sockfd);

        return 0;
}

//===============replaceString.c===============
#include "replaceString.h"

//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement){
	size_t fromLength = strlen(from);
	size_t replaceLength = strlen(replace);
	size_t replacementLength = strlen(replacement);
	size_t fromEndIt = 0;
	size_t toLength = 0;
	while(fromEndIt < fromLength){
	int replaceIt = 0;
	while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
	++replaceIt;
	}
	if(replaceIt == replaceLength){
	//Update from buffer iterator positions
	toLength += (fromEndIt + replacementLength);
	from += (fromEndIt + replaceLength);
	fromEndIt = 0;
	continue;
	}
	++fromEndIt;
	}
	toLength += fromEndIt;
	return toLength;
}
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement){
	size_t fromLength = strlen(from);
	size_t replaceLength = strlen(replace);
	size_t replacementLength = strlen(replacement);
	size_t fromEndIt = 0;
	while(fromEndIt < fromLength){
	int replaceIt = 0;
	while(replaceIt < replaceLength && (fromEndIt+replaceIt) < fromLength && from[fromEndIt + replaceIt] == replace[replaceIt]){
	++replaceIt;
	}
	if(replaceIt == replaceLength){
	//Copy the string before the matched bit
	memcpyToAndShiftPointers(to, from, fromEndIt);
	//Copy the replacement too
	memcpyToAndShiftPointer(to, replacement, replacementLength);
	//Update from buffer iterator positions
	from += replaceLength;
	fromEndIt = 0;
	continue; //I don't want this thing to get incremented again
	}
	++fromEndIt;
	}
	//Copy the rest of the unmatched string
	memcpyToAndShiftPointer(to, from, fromEndIt);
	to[0] = '\0'; //Should work
}
//===============replaceString.h===============
#ifndef REPLACE_STRING_H
#define REPLACE_STRING_H
#include <string.h>

#define memcpyToAndShiftPointer(to,from,n); memcpy((to),(from),(n)); (to) += (n);
#define memcpyToAndShiftPointers(to,from,n); memcpy((to),(from),(n)); (to) += (n); (from) += n;

//Normally I'd make a replaceStringMalloc to return a malloced string or a replaceStringMut to change the original string, but I'm not satisfied with those function names so it's best just to do to = (char*)malloc(replaceStringLength(from, replace, replacement)); replaceString(to, from, replace, replacement);
//If this was c++, I'd have no problem just overloading replaceString
//Returns the length of the resulting string (minus the null char)
size_t replaceStringLength(const char* from, const char* replace, const char* replacement);
//Baller replaceString by Leif Messinger
//Needs null terminated from, replace, and replacement strings as well as a large block of memory to store the result.
void replaceString(char* to, const char* from, const char* replace, const char* replacement);
#endif
//===============replaceStringMain.c===============
#include <stdio.h>
#include <stdlib.h>
#include "replaceString.h"

#define BUFFER_SIZE (1<<21) //About a mebibyte
//There could be matches between buffers, so make sure the buffer size you set it to is good enough for your application. Basically as big as your input.

//Replaces strings from sdtin, then outputs it to stdout
//./a.out [[replace], [replacement]]...
int main(int argc, char** argv){
	char* buffer1 = (char*) malloc(BUFFER_SIZE);
	char* buffer2 = (char*) malloc(BUFFER_SIZE);
	if(buffer1 == NULL || buffer2 == NULL){
	perror("You need a couple MBs of ram my boy");
	return 1;
	}
	while(!feof(stdin)){
	fread(buffer1, BUFFER_SIZE, 1, stdin);
	char* activeBuffer = buffer1;
	char* inactiveBuffer = buffer2;
	char* tmp;
	for(size_t i = 1; (i + 1) < argc; i += 2){
	//puts(activeBuffer);
	replaceString(inactiveBuffer, activeBuffer, argv[i], argv[i+1]);
	//Swap buffers
	tmp = activeBuffer;
	activeBuffer = inactiveBuffer;
	inactiveBuffer = tmp;
	}
	fputs(activeBuffer, stdout);
	}
	free(buffer1);
	free(buffer2);
	return 0;
}