Colony

/**

 *

 *  @author Jason Knichel

 *

 * 2/15/07

 */

#include "includes/Server.h"

#include <sys/types.h>

#include <sys/socket.h>

#include <stdio.h>

#include <string.h>

#include <netinet/in.h>

#include <unistd.h>

#include <netdb.h>

#include <stdlib.h>

#include "../lib/colonet_defs.h"

Server::Server(char * serverAddress, char * port)

{

  if (!serverAddress)

    {

      //TODO: log error message here

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "Server address was null.");

      return;

    }

  struct hostent * host = gethostbyname(serverAddress);

  if (!host)

    {

      //TODO: log error message here

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "Could not look up IP address from server address.");

      return;

    }

  int portNum = 0;

  char * endPtr = NULL;

  portNum = strtol(port, &endPtr, 10);

  if (port[0] == '\0' || *endPtr != '\0')

    {

      //TODO: log error message here

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "\nThe specified port was invalid.\n");

      return;

    }

  if (portNum < MIN_PORT || portNum > MAX_PORT)

    {

      //TODO: log error message here

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "\nThe port must be between %d and %d inclusive.\n", MIN_PORT, MAX_PORT);

      return;

    }

  //TODO: test this to make sure the string host->h_addr is the 4 byte ip

  // and not a string in dot notation

  int ipAddress = ntohl(atoi(host->h_addr));

  initializeServer(ipAddress, (unsigned short)portNum);

}

Server::Server (int ipAddress, unsigned short port)

{

  initializeServer(ipAddress, (unsigned short)port);

}

int Server::sendMsg(char * message)

{

  if (!message)

    {

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "Message was null when trying to send a message.");

      return ERROR_SERVER_PARAMETER_NULL;

    }

  if (strlen(message) > MAX_COMMAND_LEN)

    {

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "Message was too long.");

      return ERROR_SERVER_MESSAGE_LENGTH;

    }

  if (serverSocket < 0)

    {

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "The socket was not a valid file descriptor.");

      return ERROR_SERVER_SOCKET;

    }

  char * sentPoint = message;

  int needToSend = strlen(sentPoint);

  if (sentPoint[needToSend-1] != '\n')

    {

      if (needToSend == MAX_COMMAND_LEN-1)

        {

          error = 1;

          snprintf(errorMsg, MAX_ERROR_MSG_LEN, "The message was not terminated by a newline and there was no room to add one.");

          return ERROR_NO_NEWLINE;

        }

      else

        {

          sentPoint[needToSend] = '\n';

          sentPoint[needToSend+1] = '\0';

          needToSend++;

        }

    }

  while(needToSend > 0)

    {

      int sent = write(serverSocket, sentPoint, needToSend);

      if (sent < 0)

        {

          error = 1;

          snprintf(errorMsg, MAX_ERROR_MSG_LEN, "There was an error when trying to send the message to the server.");

          return ERROR_SERVER_SENDING;

        }

      needToSend -= sent;

    }

  return 1;

}

int Server::recvMessagesFromServer()

{

  char message[READ_BUFFER_SIZE];

  int maxCanRead = READ_BUFFER_SIZE - readBufferLength;

  if (maxCanRead > 0)

    {

      fd_set readSet;

      FD_ZERO(&readSet);

      FD_SET(serverSocket, &readSet);

      struct timeval t;

      memset(&t, 0, sizeof(struct timeval));

      select (serverSocket+1, &readSet, NULL, NULL, &t);

      if (!(FD_ISSET(serverSocket, &readSet)))

        {

          return 1;

        }

      printf("Before read.\n");

      int numRead = read(serverSocket, message, maxCanRead);

      printf("After read.\n");

      if (numRead < 0)

        {

          error = 1;

          snprintf(errorMsg, MAX_ERROR_MSG_LEN, "There was an error reading from the server.");

          return ERROR_SERVER_READING;

        }

      memcpy(readBuffer+readBufferLength, message, numRead);

      readBufferLength += numRead;

    }

  return 1;

}

int Server::getMsg(char * buffer, int bufferLen)

{

  if (!buffer)

    {

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "The buffer given to getMsg was null.");

      return ERROR_SERVER_PARAMETER_NULL;

    }

  if (bufferLen < 0 || bufferLen > MAX_RESPONSE_LEN)

    {

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "The buffer length given to getMsg was invalid.");

      return ERROR_SERVER_BUFFER_LENGTH;

    }

  int len = -1;

  int i;

  for (i = 0; i < readBufferLength; i++)

    {

      if (readBuffer[i] == '\n')

        {

          len = i+1;

          break;

        }

    }

  if (len == -1)

    {

      //no message found in buffer

      return 0;

    }

  if (len > MAX_RESPONSE_LEN)

    {

      //there was a message in the buffer but it was too long

      memmove(readBuffer, readBuffer+len, readBufferLength - len);

      readBufferLength -= len;

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "The next message in the buffer was too long.  Removing message from buffer.");

      return ERROR_SERVER_MESSAGE_TOO_LONG;

    }

  if (len > bufferLen)

    {

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "The next message is longer than the buffer it is trying to be stored in.  Leaving message in queue.");

      return ERROR_SERVER_NOT_ENOUGH_ROOM;

    }

  //this copies the newline over also into the buffer

  memcpy(buffer, readBuffer, len);

  memmove(readBuffer, readBuffer+len, readBufferLength - len);

  readBufferLength -= len;

  return 1;

}

int Server::isError()

{

  return error;

}

char * Server::getErrorMsg()

{

  return errorMsg;

}

void Server::clearError()

{

  memset(errorMsg, 0, MAX_ERROR_MSG_LEN);

  error = 0;

}

/******************

 *  Private Methods

 *****************/

//assumes ipAddress and port are in host format

void Server::initializeServer(int ipAddress, unsigned short port)

{

  serverSocket = socket(AF_INET, SOCK_STREAM, 0);

  if (serverSocket < 0)

    {

      //TODO: implement logging system and log error message here

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "Could not create a socket.");

      return;

    }

  struct sockaddr_in addr;

  memset (&addr, 0, sizeof(struct sockaddr_in));

  addr.sin_family = AF_INET;

  addr.sin_addr.s_addr = htonl(ipAddress);

  addr.sin_port = htons(port);

  if (connect(serverSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0)

    {

      //TODO: log error message here

      close(serverSocket);

      error = 1;

      snprintf(errorMsg, MAX_ERROR_MSG_LEN, "Could not connect to server.");

      return;

    }

  readBufferLength = 0;

  clearError();

}