Others - migrated from old site

time_t when = time(NULL);
struct tm utc = *gmtime(&when);
struct tm lcl = *localtime(&when);
int delta_h = utc.tm_hour - lcl.tm_hour;

//! Returns y characters from char* str, starting with character from position x
//! Note: it adds '\0' at the end of the array
char* subchars(char* str, short x, short y);

char* subchars(char* str, short x, short y)
{
    char* ret = new char[y + 1];
    for (short i = x; i < x + y; i++)
        ret[i - x] = str[i];
    ret[y] = '\0';
    return ret;
}

/*!
* ServerSocket.h
*
* Created on: Mar 12, 2013
* Author: Tancredi-Paul Grozav (paul@grozav.info)
*/

#ifndef SERVERSOCKET_H_
#define SERVERSOCKET_H_

#include <stdio.h> //perror, stderr, printf, fprintf
#include <cstdlib> // exit
#include <unistd.h> // fork, close
#include <string.h> // memset
#include <netdb.h> // AI_PASSIVE, getaddrinfo, gai_strerror
#include <arpa/inet.h> // inet_ntop
#include <sys/wait.h> // waitpid

/*! This class simplifies the usage of sockets */
class ServerSocket {
public:
    struct ClientSocket {
        //! Connector's address information
        struct sockaddr_storage clientAddr;
        //! Client socket file descriptor
        int connectionFileDescriptor;
    };

    typedef int (*PointerToClientHandlerFunction)(ClientSocket);

    ServerSocket(int port);
    virtual ~ServerSocket();
    /*! This method must take as an argument, the pointer to a function that takes as a parameter a ServerSocket::ClientSocket and returns an int. The int is the PID exit status */
    void acceptClient(PointerToClientHandlerFunction clientHandlerFunction);

private:
    char* portToCharArray(int port);
    int socketFileDescriptor; // listen on socketFileDescriptor,
};

#endif /* SERVERSOCKET_H_ */

/*
 * ServerSocket.cpp
 *
 * Created on: Mar 12, 2013
 * Author: Tancredi-Paul Grozav (paul@grozav.info)
 */

#include "ServerSocket.h"

void ServerSocketSignalChildHandler(int s)
{
    while (waitpid(-1, NULL, WNOHANG) > 0)
        ;
}

ServerSocket::ServerSocket(int port)
{
    //Creating and filling the hints structure, used to create the servinfo structure
    struct addrinfo hints; // filled out with relevant information
    memset(&hints, 0, sizeof hints); // make sure the struct is empty
    hints.ai_family = AF_UNSPEC; // don't care IPv4 or IPv6
    hints.ai_socktype = SOCK_STREAM; // TCP stream sockets
    hints.ai_flags = AI_PASSIVE; // use my IP

    // make servinfo point to a linked list of 1 or more struct addrinfos
    struct addrinfo *servinfo; // will point to the results (holds the interfaces)
    int rv;
    if ((rv = getaddrinfo(NULL, portToCharArray(port), &hints, &servinfo)) != 0)
    {
        fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        exit(1);
    }

    // loop through all the results and bind to the first we can
    struct addrinfo *p;
    for (p = servinfo; p != NULL; p = p->ai_next)
    {
        if ((socketFileDescriptor = socket(p->ai_family, p->ai_socktype,
            p->ai_protocol)) == -1)
        {
            perror("server: Can not call socket() on that interface");
            continue;
        }

        int yes = 1;
        if (setsockopt(socketFileDescriptor, SOL_SOCKET, SO_REUSEADDR, &yes,
            sizeof(int)) == -1)
        {
            perror("Can not call setsockopt() on that interface");
            exit(1);
        }

        if (bind(socketFileDescriptor, p->ai_addr, p->ai_addrlen) == -1)
        {
            close (socketFileDescriptor);
            perror("server: Can not call bind() on that interface");
            continue;
        }

        break;
    }

    // If we reached the end of the list
    if (p == NULL)
    {
        fprintf(stderr, "server: failed to bind\n");
        exit(2);
    }
    // free the servinfo variable
    freeaddrinfo(servinfo); // all done with this structure
    // we now have the sockfd structure

    int backLog = 10; // how many pending connections queue will hold

    if (listen(socketFileDescriptor, backLog) == -1)
    {
        perror("Can not listen() on that socket");
        exit(1);
    }

    // reap all dead processes
    // This code is responsible for reaping zombie processes
    // that appear as the fork()ed child processes exit.
    // If you make lots of zombies and don't reap them,
    // your system administrator will become agitated.
    struct sigaction sa;
    sa.sa_handler = &ServerSocketSignalChildHandler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_RESTART;
    if (sigaction(SIGCHLD, &sa, NULL) == -1)
    {
        perror("sigaction");
        exit(1);
    }
}

ServerSocket::~ServerSocket()
{
}

void ServerSocket::acceptClient(
    PointerToClientHandlerFunction clientHandlerFunction)
{
    ServerSocket::ClientSocket clientSocket;
    char s[INET6_ADDRSTRLEN];
    socklen_t sin_size = sizeof clientSocket.clientAddr;
    clientSocket.connectionFileDescriptor = accept(socketFileDescriptor,
        (struct sockaddr *) &clientSocket.clientAddr, &sin_size);
    if (clientSocket.connectionFileDescriptor == -1)
    {
        perror("Can not accept() the connection");
        // continue;
    }
    printf("Connection accepted\n");

    if (((struct sockaddr *) &clientSocket.clientAddr)->sa_family == AF_INET)
    { //IPv4 address
        inet_ntop(clientSocket.clientAddr.ss_family,
            &(((struct sockaddr_in*) ((struct sockaddr *) &clientSocket
                .clientAddr))->sin_addr), s, sizeof s);
    }
    else
    { //IPv6 address
        inet_ntop(clientSocket.clientAddr.ss_family,
            &(((struct sockaddr_in6*) ((struct sockaddr *) &clientSocket
                .clientAddr))->sin6_addr), s, sizeof s);
    }
    printf("Got connection from %s\n", s);

    pid_t pid = fork();
    if (pid == -1)
    {
        perror("Can not fork()");
    }
    else if (pid == 0)
    { // this is the child process
        exit(clientHandlerFunction(clientSocket));
    }
    else
    {
        printf("pid = %d > 0", pid);
    }
    close(clientSocket.connectionFileDescriptor); // parent doesn't need this
}

char* ServerSocket::portToCharArray(int port)
{
    int base = 10;
    static char buf[32] =
    { 0 };
    int i = 30;
    for (; port && i; --i, port /= base)
        buf[i] = "0123456789abcdef"[port % base];
    return &buf[i + 1];
}

/*!
 * main.cpp
 *
 * Created on: Mar 12, 2013
 * Author: Tancredi-Paul Grozav (paul@grozav.info)
 */
#include "ServerSocket.h"

/*! Handles a client. The int returned is the exit status of the PID created for that client. */
int clientHandler(ServerSocket::ClientSocket clientSocket)
{
// Receiving message
    char buffer[1024];
    printf("Waiting for message from client ...");
    if (recv(clientSocket.connectionFileDescriptor, &buffer, sizeof(buffer), 0)
        == -1)
        perror("Can not read from the socket");
    printf(" Client said: "%s"\n", buffer);

// Sending message
    char message[1034];
    strcpy(message, "You said: ");
    strcat(message, buffer);
    printf("char* message = "%s"\n", message);
    printf("Sending a message to the client ...");
    if (send(clientSocket.connectionFileDescriptor, message, strlen(message), 0)
        == -1)
        perror("Can not write the message to the socket");
    printf(" Message sent\n");

// Closing the socket
    printf("Disconnecting the client ...");
    close(clientSocket.connectionFileDescriptor);
    printf(" Socket closed!\n");
    return 0;
}

int main(int argc, char* argv[])
{
    ServerSocket s(1234);
    printf("server: waiting for connections...\n");
    while (1)
        s.acceptClient(&clientHandler);
    return 0;
}

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

void die(const char *msg)
{
// Print the message to standart error output stream
    perror(msg);
// Exit the program with the errorCode 1
    exit(1);
}

typedef void (*PointerToHandlerFunction)(int socketFileDescriptor);

void clientSocket_connect(const char* hostAddress, int port,
    PointerToHandlerFunction handler)
{
// Creating the socketFileDescriptor
    int socketFileDescriptor = socket(AF_INET, SOCK_STREAM, 0);
// Die if the socketFileDescriptor could not be created
    if (socketFileDescriptor < 0)
        die("ERROR opening socket");

// Get the server host
    struct hostent* server = gethostbyname(hostAddress);
// Die if the server info could not be loaded
    if (server == NULL)
        die("ERROR, no such host\n");

// Create the serverAddress structure
// Define the serverAddress structure
    struct sockaddr_in serverAddress;
// Zero-fill the structure
    bzero((char*) &serverAddress, sizeof(serverAddress));
// Set the sin_family member
    serverAddress.sin_family = AF_INET;
// Set the HOST ADDRESS
    bcopy((char*) server->h_addr, (char*)&serverAddress.sin_addr.s_addr, server->h_length);
// Set the PORT NUMBER
    serverAddress.sin_port = htons(port);

// Connect to the server using the serverAddress structure or die
    if (connect(socketFileDescriptor, (struct sockaddr*) &serverAddress,
        sizeof(serverAddress)) < 0)
        die("ERROR connecting");

// Call the handler function
    handler(socketFileDescriptor);

// Close the socket
    close(socketFileDescriptor);
}

void connectionHandler(int socketFileDescriptor)
{
// Send data
// Define the buffer
    char buffer[256];
// Set the message in that buffer (bytes to be sent)
    strcpy(buffer,
        "GET /maya/ HTTP/1.1nhost: debian.server.paul.grozav.infon\n");
// Write the bytes to the socket
    int n = write(socketFileDescriptor, buffer, strlen(buffer));
// Die if you couldn't write those bytes
    if (n < 0)
        die("ERROR writing to socket");

// Clear the buffer - we'll read data to the same buffer
    bzero(buffer, 256);

// Read data to buffer
// Read from socket and store to buffer
    n = read(socketFileDescriptor, buffer, 255);
// Die if you couldn't read
    if (n < 0)
        die("ERROR reading from socket");

// Print the received bytes
    printf("%s\n", buffer);
}

int main(int argc, char* argv[])
{
    clientSocket_connect("debian.server.paul.grozav.info", 80,
        &connectionHandler);
    return 0;
}

#include <iostream> // for cout and endl
#include <cstring> // for memcpy
struct header {
    char a;
    unsigned int b;
};
int main(int argc, char* argv[]){
    // Creating a structure and filling it with data
    header h;
    h.a = 51;
    h.b = 3147483647;// greater than MAX_VALUE for signed int (2147483647)

    // Create a buffer, and write the structure
    char buffer[ sizeof(h.a) + sizeof(h.b) ];// 1 for char + 4 for int = 5 bytes
    buffer[0]=h.a;
    memcpy( buffer+1, &h.b, sizeof(h.b) );

    // Printing the buffer
    std::cout.write( buffer, 5 );
    std::cout << std::endl;

    // Create a new structure using the data from the buffer
    header n;
    n.a = buffer[0];
    // unsigned int* pointerToUnsignedInt = (unsigned int*)(buffer + 1);
    // n.b = *pointerToUnsignedInt;
    // Or simply:
    n.b = *((unsigned int*)(buffer + 1));//value of (pointer to (unsigned int) )

    // Print the new structure
    std::cout << "n.a = " << n.a << " (as char) = " << (int)n.a << " (as int)" << std::endl;
    std::cout << "n.b=" << n.b << std::endl;

    return 0;
}

#include <iostream> // for cout and endl
#include <cstring> // for memcpy
struct header {
    char a;
    unsigned int b;
};
int main(int argc, char* argv[]){
    // Creating a structure and filling it with data
    header h;
    h.a = 51;
    h.b = 3147483647;// greater than MAX_VALUE for signed int (2147483647)

    // Create a buffer, and write the structure
    char* buffer = (char*)&h;

    // Printing the buffer
    std::cout.write( buffer, sizeof(h) );
    std::cout << std::endl;

    // Create a new structure using the data from the buffer
    header n = *((header*)buffer);//value of (pointer to (header) )

    // Print the new structure
    std::cout << "n.a = " << n.a << " (as char) = " << (int)n.a << " (as int)" << std::endl;
    std::cout << "n.b = " << n.b << std::endl;

    return 0;
}

#include <iostream>
#include <sys/time.h>
using namespace std;
int main(int argc, char* argv[]){
    timeval t1;
    gettimeofday( &t1, NULL );
    cout << "Program running "; cout.flush();
    for(int a=0; a<3; a++){
        for(int b=0; b<10000; b++)
            for(int c=0; c<100000; c++){}
                cout << "."; cout.flush();
    }
    cout << "nProgram END !n";
    timeval t2;
    gettimeofday( &t2, NULL );
    timeval delta;
    delta.tv_sec = t2.tv_sec - t1.tv_sec;
    delta.tv_usec = t2.tv_usec - t1.tv_usec;
    if(delta.tv_usec < 0){
        delta.tv_usec += 1000000;
        delta.tv_sec -= 1;
    }
    cout << "Runtime: " << delta.tv_sec << " seconds and " << delta.tv_usec << " microseconds (that is 1/(10^6) seconds)" << endl;
    return 0;
}

#include <iostream>
#include <time.h> // for clock_gettime()
#include <unistd.h> // for sleep()

using namespace std;

int main(int argc, char* argv[])
{
    struct timespec start, end;
    unsigned long long int diff;

    // Measure monotonic time
    clock_gettime(CLOCK_MONOTONIC, &start); // start
    sleep(1); // do stuff
    clock_gettime(CLOCK_MONOTONIC, &end); // end
    // print Delta
    diff = 1000000000L * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
    cout << "elapsed time = " << diff << " nanoseconds" << endl;

    // Measure CPU time
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); // start
    sleep(1); // do stuff
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); // end
    // print Delta
    diff = 1000000000L * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
    cout << "elapsed process CPU time = " << diff << " nanoseconds" << endl;

    return 0;
}

//
// bytesToAsciiAndBinary.cpp
//
// Created on: Apr 3, 2013
// Author: Tancredi-Paul Grozav (paul@grozav.info)
//
#include <iostream> // for cout
#include <fstream> // for ifstream, ofstream
#include <bitset> // for converting to binary
#include <limits.h> // for converting to binary (CHAR_BIT)
#include <cstring> // for strcmp
using namespace std;
/*!
Parameters:
./bytesToAsciiAndBinary inputFile [outputFile]
For each byte in the inputFile, it writes it's ASCII value and it's binary value in the outputFile, separated by a space (" ")
If the outputFile parameter is missing then it prints the values to stdout.
*/
int main(int argc, char* argv[]){
    if(argc == 1){
        cerr << "Please specify an inputFile as the first parameter" << endl;
    }else if(argc >= 2){
        if( strcmp(argv[1], "-h") == 0 ){
            cout << "./bytesToAsciiAndBinary inputFile [outputFile]nFor each byte in the inputFile, it writes it's ASCII value and it's binary value in the outputFile, separated by a space (" ")nIf the outputFile parameter is missing then it prints the values to stdout." << endl;
            return 0;
        }
        char* inputFileName = argv[1];
        ifstream inputFile( inputFileName );
        ofstream outputFile;
        if(argc == 3) outputFile.open( argv[2] );
        char c;//character read from the file
        while( inputFile.good() ){//loop while extraction from file is possible
            c = inputFile.get();//read the caracter from the file
            if(argc == 2)
                cout << (short int)((unsigned char)c) << " " << std::bitset<CHAR_BIT>( c ) << endl;
            if(argc == 3)
                outputFile <<(short int)((unsigned char)c) << " " << std::bitset<CHAR_BIT>( c ) << endl;
        }
        inputFile.close();
        if(argc == 3) outputFile.close();
    }
}

//
// Utils.h
//
// Created on: Aug 29, 2012
// Author: Tancredi-Paul Grozav (paul@grozav.info)
//

#ifndef UTILS_H_
#define UTILS_H_

#include <string>
#include <vector>

using namespace std;

namespace gtp{
//! Other functions needed through the program (Functions created by Tancredi-Paul Grozav - paul@grozav.info )
class Utils {
public:
    Utils();
    virtual ~Utils();

    //! Returns the position of the first digit, based on isdigit()
    static int firstDigitPosition(string s);
    //! Right trim
    static string rtrim(string s);
    //! Left trim
    static string ltrim(string s);
    //! Left and right trim
    static string trim(string s);

    //! Converts a given int to string
    static string intToStr(int v);
    //! Converts a given double to string
    static string doubleToStr(double v);
    //! Converts a given long to string
    static string longToStr(long v);
    //! Converts a given string to char*
    static char* stringToCharArr(string s);
    //! Executes the given command on the current operating system
    static int run(string command);
    //! Checks if the specified file exists or not
    static bool fileExists(string filename);
    //! Checks if the specified directory exists or not
    static bool directoryExists(string dirName);
    //! Converts a given month to it's code value
    static string monthToCode(string month);
    //! Explodes a string by a given character. Ex: eplodeStringByCharacter("ana,are,mere", ',')={"ana", "are", "mere"}
    static vector<string> explodeStringByCharacter(string str, char ch);
    //! Reads the content of a given file, into a string variable, and returns it's value
    static string readFileToString(string file);
    //! Adds as many "0"es as needed in order to represent the given on n digits
    static string nDigits(int nr, unsigned long n);
    //! Removes all occurences of character c in string s
    static string removeCharacter(string s, char c);
    //! Returns all characters from string s that come after the first character left and the first character right
    static string betweenChars(string s, char left, char right);
    //! Returns a string of length n, filled with character c
    static string returnNTimesChar(char c, unsigned long n);
};

}//! Ending namespace gtp
#endif//! UTILS_H_

//
// Utils.cpp
//
// Created on: Aug 29, 2012
// Author: Tancredi-Paul Grozav <paul@grozav.info>
//

#include "Utils.h"
#include <algorithm>
#include <iostream>
#include <string>
#include <string.h>//for strcpy
#include <vector>
#include <sstream>
#include <fstream>
#include <cstdlib>
#include <sys/stat.h>

using namespace std;

namespace gtp {

Utils::Utils(){}
Utils::~Utils(){}

string Utils::intToStr(int v) {
    // Create a stringstream
    stringstream ss;
    // Add number to the stream
    ss << v;
    // Return a string with the contents of the stream
    return ss.str();
}

string Utils::doubleToStr(double v) {
    // Create a stringstream
    stringstream ss;
    // Add number to the stream
    ss << v;
    // Return a string with the contents of the stream
    return ss.str();
}

string Utils::longToStr(long v) {
    // Create a stringstream
    stringstream ss;
    // Add number to the stream
    ss << v;
    // Return a string with the contents of the stream
    return ss.str();
}

char* Utils::stringToCharArr(string s){
    char* buf = new char[s.size()];
    strcpy(buf, s.c_str());
    return buf;
}

int Utils::firstDigitPosition(string s){
    for(unsigned int i = 0; i < s.size(); i++)
        if( isdigit( s.at(i) ) )
            return i;
    return -1;
}

// TRIM FUNCTIONS
string Utils::rtrim(string s){
    while(s.at(s.size()-1) == ' ')
        s = s.substr(0, s.size()-1);
    return s;
}
string Utils::ltrim(string s){
    while(s.at(0) == ' ')
        s = s.substr(1, s.size()-1);
    return s;
}
string Utils::trim(string s){return ltrim(rtrim(s)); }

int Utils::run(string command) {
    return system(command.c_str());
}

bool Utils::fileExists(string fileName){
    ifstream f(fileName.c_str());
    return f;
}
bool Utils::directoryExists(string dirName){
    struct stat myStat;
    return (stat(dirName.c_str(), &myStat) == 0) && (((myStat.st_mode) & S_IFMT) == S_IFDIR);
}

string Utils::monthToCode(string month){
    if(month == "01") return "F";
    else if(month == "02") return "G";
    else if(month == "03") return "H";
    else if(month == "04") return "J";
    else if(month == "05") return "K";
    else if(month == "06") return "M";
    else if(month == "07") return "N";
    else if(month == "08") return "Q";
    else if(month == "09") return "U";
    else if(month == "10") return "V";
    else if(month == "11") return "X";
    else if(month == "12") return "Z";
    else return "?";
}

vector<string> Utils::explodeStringByCharacter(string str, char ch) {
    std::string next = "";
    std::vector<std::string> result;
    // For each character in the string
    for (unsigned int i = 0; i < str.size(); i++) {
        // If we've hit the terminal character
        if (str.at(i) == ch) {
            // If we have some characters accumulated
                if (next.length() > 0) {
                    // Add them to the result vector
                    result.push_back(next);
                    next = "";
                }
        } else {
            // Accumulate the next character into the sequence
            next += str.at(i);
        }
    }
    result.push_back(next);
    return result;
}

string Utils::readFileToString(string file){
    ifstream f(file.c_str());
    // Buffer
    stringstream b;
    b << f.rdbuf();
    return b.str();
}

string Utils::nDigits(int nr, unsigned long n){
    string nrStr = intToStr(nr);
    unsigned long nrLen = nrStr.size();
    if(nrLen > n) return "";
    if(nrLen == n) return nrStr;
    string prefix = "";
    for(unsigned long i = 0; i<n-nrLen; i++)
        prefix += "0";
    return prefix+nrStr;
}

string Utils::removeCharacter(string s, char c){
    s.erase(remove(s.begin(), s.end(), c), s.end());
    return s;
}

string Utils::betweenChars(string s, char left, char right){
    unsigned int pos = s.find_first_of(left);
    if (pos == string::npos) return s;
    string st = s.substr(pos+1, s.size()-pos-1);
    pos = st.find_first_of(right);
    if (pos == string::npos) return s;
    st = st.substr(0, pos);
    return st;
}

string Utils::returnNTimesChar(char c, unsigned long n){
    if(n > 10){
        std::cout << "You asked to return " << n << " times the caracter '" << c << "'. That is weird!" <<std::endl;
    }
    string r = "";
    for(; n >= 1; n--){
        r += c;
    }
    return r;
}

}// Ending Name space

#include <iostream>
using namespace std;

class Number{
public:
    Number(int a){ x=a; }
    friend ostream& operator<<(ostream& os, const Number& s);
    int x;
};
ostream& operator<<(ostream& os, const Number& s){
    os << "Number(" << s.x << ")"; return os;
}

class String{
public:
    String(string a){ x=a; }
    friend ostream& operator<<(ostream& os, const String& s);
    string x;
};
ostream& operator<<(ostream& os, const String& s){
    os << s.x; return os;
}

void* giveMeA(string what){
    if(what == "string"){
        return new String("This is a String sample");
    }else if(what == "number"){
        return new Number(230001);
    }
}

int main(int argc, char* argv[]){
    String s = *((String*)giveMeA("string"));
    cout << s << endl;
    Number n = *((Number*)giveMeA("number"));
    cout << n << endl;
    return 0;
}

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

void die(const char *msg){
// Print the message to standard error output stream
perror(msg);
// Exit the program with the errorCode 1
exit(1);
}

typedef void (*PointerToHandlerFunction)(int socketFileDescriptor);

void clientSocket_connect(const char* hostAddress, int port, PointerToHandlerFunction handler){
// Creating the socketFileDescriptor
int socketFileDescriptor = socket(AF_INET, SOCK_STREAM, 0);
// Die if the socketFileDescriptor could not be created
if(socketFileDescriptor < 0) die("ERROR opening socket");

// Get the server host
struct hostent* server = gethostbyname(hostAddress);
// Die if the server info could not be loaded
if(server == NULL) die("ERROR, no such host\n");

// Create the serverAddress structure
// Define the serverAddress structure
struct sockaddr_in serverAddress;
// Zero-fill the structure
bzero((char*)&serverAddress, sizeof(serverAddress));
// Set the sin_family member
serverAddress.sin_family = AF_INET;
// Set the HOST ADDRESS
bcopy((char*)server->h_addr, (char*)&serverAddress.sin_addr.s_addr, server->h_length);
// Set the PORT NUMBER
serverAddress.sin_port = htons(port);

// Connect to the server using the serverAddress structure or die
if (connect(socketFileDescriptor, (struct sockaddr*)&serverAddress, sizeof(serverAddress)) < 0) die("ERROR connecting");

// Call the handler function
handler(socketFileDescriptor);

// Close the socket
close(socketFileDescriptor);
}

void connectionHandler(int socketFileDescriptor){
// Send data
// Define the buffer
char buffer[2048];
// Set the message in that buffer (bytes to be sent)
// strcpy(buffer, "GET /maya/ HTTP/1.1\r\nhost: debian.server.paul.grozav.info\r\n\r\n"); // GET request

// POST Request
// strcpy(buffer, "POST /php/post.php HTTP/1.1\r\nContent-Type: application/x-www-form-urlencoded\r\nHost: debian.server.paul.grozav.info\r\nContent-Length: 32\r\n\r\nusername=grozav1&password=paul12");
strcpy(buffer, "POST /php/post.php HTTP/1.1\r\n");
strcat(buffer, "Content-Type: application/x-www-form-urlencoded\r\n");
strcat(buffer, "Host: debian.server.paul.grozav.info\r\n");
strcat(buffer, "Content-Length: 32\r\n");
strcat(buffer, "\r\n");
strcat(buffer, "username=grozav1&password=paul12");
// Write the bytes to the socket
int n = write(socketFileDescriptor, buffer, strlen(buffer));
// Die if you couldn’t write those bytes
if(n < 0) die("ERROR writing to socket");

// Clear the buffer – we’ll read data to the same buffer
bzero(buffer,256);

// Read data to buffer
// Read from socket and store to buffer
n = read(socketFileDescriptor, buffer, 255);
// Die if you couldn’t read
if(n < 0) die("ERROR reading from socket");

// Print the received bytes
printf("%s\n", buffer);
}

int main(int argc, char* argv[]){
// clientSocket_connect("debian.server.paul.grozav.info", 80, &connectionHandler);
clientSocket_connect("debian.server.paul.grozav.info", 80, &connectionHandler);
return 0;
}

#include <iostream>
using namespace std;

class Car{
public:
    Car(string m, int ns);
    friend ostream& operator<<(ostream &out, const Car& c);
private:
    int numberOfSeats;
    string manufacturer;
};

Car::Car(string m, int ns){
    numberOfSeats = ns;
    manufacturer = m;
}

ostream& operator<<(ostream &out, const Car& c)
{
    out << "Car{" << endl;
    out << "tmanufacturer: " << c.manufacturer << endl;
    out << "tnumberOfSeats: " << c.numberOfSeats << endl;
    out << "}" << endl;
    return out;
}

int main(int argc, char* argv[]){
    Car t("Dacia", 29);
    cout << t << endl;
    return 0;
}

paul@grozav:~/Desktop$ g++ -o oo oo.cpp && ./oo
Car{
manufacturer: Dacia
numberOfSeats: 29
}

paul@grozav:~/Desktop$

#include <iostream>
using namespace std;

class Processor
{
public:
static Processor& getInstance();
void process();
private:
Processor();
~Processor();
Processor(const Processor&);// Prevent copy-construction
Processor& operator=(const Processor&);// Prevent assignment
};

Processor& Processor::getInstance()
{
static Processor p;
return p;
}

void Processor::process()
{
cout << "Processing ..." << endl;
}

Processor::Processor()
{
cout << "Process constructor" << endl;
}

Processor::~Processor()
{
cout << "Process destructor" << endl;
}

int main(int argc, char* argv[])
{
Processor& p = Processor::getInstance();
p.process();

Processor& y = Processor::getInstance();
y.process();
return 0;
}

#include <stdio.h> // perror
#include <arpa/inet.h> // inet_addr
#include <stdlib.h> // exit, atoi
#include <string.h> // strlen, memset
#include <unistd.h> // close

int main(int argc, char *argv[]) {
    if (argc != 4) {
        fprintf(stderr, "USAGE: %s <server_ip> <word> <port>n", argv[0]);
        exit(1);
    }

    // Create the UDP socket
    int sock;
    if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) fprintf(stdout, "Failed to create socket");

    // Construct the server sockaddr_in structure
    struct sockaddr_in echoserver;
    memset(&echoserver, 0, sizeof(echoserver)); // Clear struct
    echoserver.sin_family = AF_INET; // Internet/IP socket - not bluetooth or InfraRed
    echoserver.sin_addr.s_addr = inet_addr(argv[1]); // IP address
    echoserver.sin_port = htons(atoi(argv[3])); // server port

    // Send the word
    unsigned int echolen = strlen(argv[2]);
    if(sendto(sock, argv[2], echolen, 0, (struct sockaddr *) &echoserver, sizeof(echoserver)) != echolen)
    fprintf(stdout, "Could not send all bytes");

    close(sock);
    exit(0);
}

struct tm t;
t.tm_year = 70;// This is year-1900, so year = 1970
t.tm_mon = 0;
t.tm_mday = 1;
t.tm_hour = 0;
t.tm_min = 20321;
t.tm_sec = 12992;
time_t timeSinceEpoch = mktime(&t);//compute the date

long int date = (t.tm_year + 1900)*10000//we add 4 zeros to the right for MM DD (month and day)
+(t.tm_mon + 1)*100//we add 2 zeros to the right for DD (days)
+t.tm_mday;

#include <iostream> // std::cout
#include <cstring> // std::getline()
int main(int argc, char* argv[])
{
    char line[4*1024] = "ana";
    std::cout << line << std::endl;
    std::cout << "strlen(line)=" << strlen(line) << std::endl;
    std::cout << "sizeof(line)=" << sizeof(line) << std::endl;
    return 0;
}

#include <iostream> // std::cout
#include <cstring> // std::getline()
int main(int argc, char* argv[])
{
    char line[4] = "abcd";
    std::cout << line << std::endl;
    std::cout << "strlen(line)=" << strlen(line) << std::endl;
    std::cout << "sizeof(line)=" << sizeof(line) << std::endl;
    return 0;
}

#include <iostream> // std::cout
#include <cstring> // std::getline()
int main(int argc, char* argv[])
{
    char line[4] = {'a', 'b', 'c', 'd'};
    std::cout << line << std::endl;
    std::cout << "strlen(line)=" << strlen(line) << std::endl;
    std::cout << "sizeof(line)=" << sizeof(line) << std::endl;
    return 0;
}