class scSocket
{
   public:
      int scSend(char* data, int size);
      int scRecv(char* data, int size);

      int scRecvcallback();

      int scGetlasterror();

   protected:
      int sock;
      int error;
};


class scClient : public scSocket
{
   public:
      scClient();
      scClient(char* host, int port);

      ~scClient();


      int scConnect(char* host, int port);

   protected:
      bool scTryhostname(char* host, int port);
      bool scTryip(char* host, int port);
      
      struct sockaddr_in server;
      struct hostent *server2;
      
};


class scServer : public scSocket
{
   public:
      scServer();
      scServer(int port);
      ~scServer();

      int scListen(int port);

   protected:
      int listener;
      struct sockaddr_in aserver, aclient;
};


int scSocket::scSend(char* data, int size)
{
   int ret = write(sock, data, size);
   if(ret != size)
   {
      cout << "error sending data\nsend returned " << ret << endl;
      error = 4;
      return ret;
   }
   cout << "data sent" << endl;
   return 0;
}

int scSocket::scRecv(char* data, int size)
{
   int ret = read(sock, data, size);
   if(ret < 0)
   {
      cout << "error recving data\nrecv() returned " << ret << endl;
      error = 4;
   }
   cout << "data recved" << endl;
   return ret;
}

int scServer::scListen(int port)
{
   memset(&aserver, 0, sizeof(aserver));
   aserver.sin_family = AF_INET;
   aserver.sin_addr.s_addr = htonl(INADDR_ANY);
   aserver.sin_port = htons(port);

   if(bind(listener, (struct sockaddr *) &aserver, sizeof(aserver)) < 0)
   {
      cout << "error binding socket!\n";
      error = 1;
      return -1;
   }

   cout << "socket bound\n";
   listen(listener, 5);
   cout << "listening . . .\n";
   unsigned int clen = sizeof(aclient);

   if(sock = accept(listener, (struct sockaddr *) &aclient, &clen) < 0)
   {
      cout << "error accepting client!\n";
      error = 3;
      return -3;
   }

   cout << "connection accepted!\n";
   return 1;
}


scServer::scServer()
{
   listener = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
   if(listener < 0)
   {
      cout << "error creating listener socket" << endl;
      error = 1;
   }
   cout << "socket created\n";
}


int main()
{
   scServer ss(4651);

   char buf[50];
   bzero(buf, 50);

   ss.scRecv(buf, 50);

   cout << buf << endl;
}

int scSocket::scRecv(char* data, int size)
{
	cout << "waiting to recv data\n";
	int ret = recv(sock, data, size, 0);
	if(ret < 0)
	{
		cout << "error recving data\nrecv() returned " << ret << endl;
		cout << h_errno << endl;
		error = 4;
	}
	cout << "data recved" << endl;
	return ret;
}

error recving data
recv() returned -1
0