Merge branch 'master' of octo.ddvtech.com:pls

util/amf.cpp

@@ -2,6 +2,7 @@
 /// Holds all code for the AMF namespace.
 
 #include "amf.h"
+#include <cstdio> //needed for stderr only
 
 /// Returns the std::string Indice for the current object, if available.
 /// Returns an empty string if no indice exists.

util/flv_tag.cpp

@@ -7,7 +7,6 @@
 #include <fcntl.h> //for Tag::FileLoader
 #include <stdlib.h> //malloc
 #include <string.h> //memcpy
-#include "ddv_socket.h" //socket functions
 
 char FLV::Header[13]; ///< Holds the last FLV header parsed.
 bool FLV::Parse_Error = false; ///< This variable is set to true if a problem is encountered while parsing the FLV.
@@ -261,7 +260,7 @@ bool FLV::Tag::MemLoader(char * D, unsigned int S, unsigned int & P){
 /// \param sofar Current amount read.
 /// \param sock Socket to read from.
 /// \return True if count bytes are read succesfully, false otherwise.
-bool FLV::Tag::SockReadUntil(char * buffer, unsigned int count, unsigned int & sofar, DDV::Socket & sock){
+bool FLV::Tag::SockReadUntil(char * buffer, unsigned int count, unsigned int & sofar, Socket::Connection & sock){
   if (sofar == count){return true;}
   if (!sock.read(buffer + sofar,count-sofar)){
     if (errno != EWOULDBLOCK){
@@ -284,7 +283,7 @@ bool FLV::Tag::SockReadUntil(char * buffer, unsigned int count, unsigned int & s
 /// While this function returns false, the Tag might not contain valid data.
 /// \param sock The socket to read from.
 /// \return True if a whole tag is succesfully read, false otherwise.
-bool FLV::Tag::SockLoader(DDV::Socket sock){
+bool FLV::Tag::SockLoader(Socket::Connection sock){
   if (buf < 15){data = (char*)realloc(data, 15); buf = 15;}
   if (done){
     if (SockReadUntil(data, 11, sofar, sock)){
@@ -325,7 +324,7 @@ bool FLV::Tag::SockLoader(DDV::Socket sock){
 /// \param sock The socket to read from.
 /// \return True if a whole tag is succesfully read, false otherwise.
 bool FLV::Tag::SockLoader(int sock){
-  return SockLoader(DDV::Socket(sock));
+  return SockLoader(Socket::Connection(sock));
 }//Tag::SockLoader
 
 /// Helper function for FLV::FileLoader.

util/flv_tag.h

@@ -2,7 +2,7 @@
 /// Holds all headers for the FLV namespace.
 
 #pragma once
-#include "ddv_socket.h"
+#include "socket.h"
 #include <string>
 
 /// This namespace holds all FLV-parsing related functionality.
@@ -31,7 +31,7 @@ namespace FLV {
       //loader functions
       bool MemLoader(char * D, unsigned int S, unsigned int & P);
       bool SockLoader(int sock);
-      bool SockLoader(DDV::Socket sock);
+      bool SockLoader(Socket::Connection sock);
       bool FileLoader(FILE * f);
     protected:
       int buf; ///< Maximum length of buffer space.
@@ -39,7 +39,7 @@ namespace FLV {
       unsigned int sofar; ///< How many bytes are read sofar?
       //loader helper functions
       bool MemReadUntil(char * buffer, unsigned int count, unsigned int & sofar, char * D, unsigned int S, unsigned int & P);
-      bool SockReadUntil(char * buffer, unsigned int count, unsigned int & sofar, DDV::Socket & sock);
+      bool SockReadUntil(char * buffer, unsigned int count, unsigned int & sofar, Socket::Connection & sock);
       bool FileReadUntil(char * buffer, unsigned int count, unsigned int & sofar, FILE * f);
   };//Tag
 

util/http_parser.cpp

@@ -127,11 +127,11 @@ void HTTP::Parser::SetVar(std::string i, std::string v){
   vars[i] = v;
 }
 
-/// Attempt to read a whole HTTP request or response from DDV::Socket sock.
+/// Attempt to read a whole HTTP request or response from Socket::Connection.
 /// \param sock The socket to use.
 /// \param nonblock When true, will not block even if the socket is blocking.
 /// \return True of a whole request or response was read, false otherwise.
-bool HTTP::Parser::Read(DDV::Socket & sock, bool nonblock){
+bool HTTP::Parser::Read(Socket::Connection & sock, bool nonblock){
   if (nonblock && (sock.ready() < 1)){return parse();}
   sock.read(HTTPbuffer);
   return parse();
@@ -206,20 +206,20 @@ bool HTTP::Parser::parse(){
 
 /// Sends data as response to conn.
 /// The response is automatically first build using HTTP::Parser::BuildResponse().
-/// \param conn The DDV::Socket to send the response over.
+/// \param conn The Socket::Connection to send the response over.
 /// \param code The HTTP response code. Usually you want 200.
 /// \param message The HTTP response message. Usually you want "OK".
-void HTTP::Parser::SendResponse(DDV::Socket & conn, std::string code, std::string message){
+void HTTP::Parser::SendResponse(Socket::Connection & conn, std::string code, std::string message){
   std::string tmp = BuildResponse(code, message);
   conn.write(tmp);
 }
 
 /// Sends data as HTTP/1.1 bodypart to conn.
 /// HTTP/1.1 chunked encoding is automatically applied if needed.
-/// \param conn The DDV::Socket to send the part over.
+/// \param conn The Socket::Connection to send the part over.
 /// \param buffer The buffer to send.
 /// \param len The length of the buffer.
-void HTTP::Parser::SendBodyPart(DDV::Socket & conn, char * buffer, int len){
+void HTTP::Parser::SendBodyPart(Socket::Connection & conn, char * buffer, int len){
   std::string tmp;
   tmp.append(buffer, len);
   SendBodyPart(conn, tmp);
@@ -227,9 +227,9 @@ void HTTP::Parser::SendBodyPart(DDV::Socket & conn, char * buffer, int len){
 
 /// Sends data as HTTP/1.1 bodypart to conn.
 /// HTTP/1.1 chunked encoding is automatically applied if needed.
-/// \param conn The DDV::Socket to send the part over.
+/// \param conn The Socket::Connection to send the part over.
 /// \param bodypart The data to send.
-void HTTP::Parser::SendBodyPart(DDV::Socket & conn, std::string bodypart){
+void HTTP::Parser::SendBodyPart(Socket::Connection & conn, std::string bodypart){
   if (protocol == "HTTP/1.1"){
     static char len[10];
     int sizelen;

util/http_parser.h

@@ -6,7 +6,7 @@
 #include <string>
 #include <stdlib.h>
 #include <stdio.h>
-#include "ddv_socket.h"
+#include "socket.h"
 
 /// Holds all HTTP processing related code.
 namespace HTTP{
@@ -14,7 +14,7 @@ namespace HTTP{
   class Parser{
     public:
       Parser();
-      bool Read(DDV::Socket & sock, bool nonblock = true);
+      bool Read(Socket::Connection & sock, bool nonblock = true);
       bool Read(FILE * F);
       std::string GetHeader(std::string i);
       std::string GetVar(std::string i);
@@ -25,9 +25,9 @@ namespace HTTP{
       void SetBody(char * buffer, int len);
       std::string BuildRequest();
       std::string BuildResponse(std::string code, std::string message);
-      void SendResponse(DDV::Socket & conn, std::string code, std::string message);
-      void SendBodyPart(DDV::Socket & conn, char * buffer, int len);
-      void SendBodyPart(DDV::Socket & conn, std::string bodypart);
+      void SendResponse(Socket::Connection & conn, std::string code, std::string message);
+      void SendBodyPart(Socket::Connection & conn, char * buffer, int len);
+      void SendBodyPart(Socket::Connection & conn, std::string bodypart);
       void Clean();
       bool CleanForNext();
       std::string body;

util/rtmpchunks.cpp

@@ -42,7 +42,7 @@ std::string RTMPStream::Chunk::Pack(){
   unsigned int tmpi;
   unsigned char chtype = 0x00;
   timestamp -= firsttime;
-  if (prev.cs_id == cs_id){
+  if ((prev.msg_type_id > 0) && (prev.cs_id == cs_id)){
     if (msg_stream_id == prev.msg_stream_id){
       chtype = 0x40;//do not send msg_stream_id
       if (len == prev.len){
@@ -292,6 +292,7 @@ bool RTMPStream::Chunk::Parse(std::string & indata){
       break;
     case 0x40:
       if (indata.size() < i+7) return false; //can't read whole header
+      if (prev.msg_type_id == 0){fprintf(stderr, "Warning: Header type 0x40 with no valid previous chunk!\n");}
       timestamp = indata[i++]*256*256;
       timestamp += indata[i++]*256;
       timestamp += indata[i++];
@@ -305,6 +306,7 @@ bool RTMPStream::Chunk::Parse(std::string & indata){
       break;
     case 0x80:
       if (indata.size() < i+3) return false; //can't read whole header
+      if (prev.msg_type_id == 0){fprintf(stderr, "Warning: Header type 0x80 with no valid previous chunk!\n");}
       timestamp = indata[i++]*256*256;
       timestamp += indata[i++]*256;
       timestamp += indata[i++];
@@ -315,6 +317,7 @@ bool RTMPStream::Chunk::Parse(std::string & indata){
       msg_stream_id = prev.msg_stream_id;
       break;
     case 0xC0:
+      if (prev.msg_type_id == 0){fprintf(stderr, "Warning: Header type 0xC0 with no valid previous chunk!\n");}
       timestamp = prev.timestamp;
       len = prev.len;
       len_left = prev.len_left;

util/server_setup.cpp

@@ -21,14 +21,14 @@
   #error "No configuration file section was set!"
 #endif
 
-#include "ddv_socket.h" //DDVTech Socket wrapper
+#include "socket.h" //Socket library
 #include <signal.h>
 #include <sys/types.h>
 #include <pwd.h>
 #include <fstream>
 #define defstr(x) #x ///< converts a define name to string
 #define defstrh(x) "[" defstr(x) "]" ///< converts define name to [string]
-DDV::ServerSocket server_socket(-1); ///< Placeholder for the server socket
+Socket::Server server_socket(-1); ///< Placeholder for the server socket
 
 /// Basic signal handler. Disconnects the server_socket if it receives
 /// a SIGINT, SIGHUP or SIGTERM signal, but does nothing for SIGPIPE.
@@ -53,7 +53,7 @@ void signal_handler (int signum){
 /// The default port is set by define #DEFAULT_PORT.
 /// The configuration file section is set by define #CONFIGSECT.
 int main(int argc, char ** argv){
-  DDV::Socket S;//placeholder for incoming connections
+  Socket::Connection S;//placeholder for incoming connections
 
   //setup signal handler
   struct sigaction new_action;
@@ -135,7 +135,7 @@ int main(int argc, char ** argv){
   }//configuration
 
   //setup a new server socket, for the correct interface and port
-  server_socket = DDV::ServerSocket(listen_port, interface);
+  server_socket = Socket::Server(listen_port, interface);
   #if DEBUG >= 3
   fprintf(stderr, "Made a listening socket on %s:%i...\n", interface.c_str(), listen_port);
   #endif

util/socket.cpp

@@ -1,40 +1,42 @@
-/// \file ddv_socket.cpp
-/// Holds all code for the DDV namespace.
+/// \file socket.cpp
+/// A handy Socket wrapper library.
+/// Written by Jaron Vietor in 2010 for DDVTech
 
-#include "ddv_socket.h"
+#include "socket.h"
 
-/// Create a new base socket. This is a basic constructor for converting any valid socket to a DDV::Socket.
+/// Create a new base socket. This is a basic constructor for converting any valid socket to a Socket::Connection.
 /// \param sockNo Integer representing the socket to convert.
-DDV::Socket::Socket(int sockNo){
+Socket::Connection::Connection(int sockNo){
   sock = sockNo;
   Error = false;
   Blocking = false;
-}//DDV::Socket basic constructor
+}//Socket::Connection basic constructor
 
 /// Create a new disconnected base socket. This is a basic constructor for placeholder purposes.
 /// A socket created like this is always disconnected and should/could be overwritten at some point.
-DDV::Socket::Socket(){
+Socket::Connection::Connection(){
   sock = -1;
   Error = false;
   Blocking = false;
-}//DDV::Socket basic constructor
+}//Socket::Connection basic constructor
 
 /// Close connection. The internal socket is closed and then set to -1.
-void DDV::Socket::close(){
-  #if DEBUG >= 3
+void Socket::Connection::close(){
+  #if DEBUG >= 4
   fprintf(stderr, "Socket closed.\n");
   #endif
+  shutdown(sock, SHUT_RDWR);
   ::close(sock);
   sock = -1;
-}//DDV::Socket::close
+}//Socket::Connection::close
 
 /// Returns internal socket number.
-int DDV::Socket::getSocket(){return sock;}
+int Socket::Connection::getSocket(){return sock;}
 
 /// Create a new Unix Socket. This socket will (try to) connect to the given address right away.
 /// \param address String containing the location of the Unix socket to connect to.
 /// \param nonblock Whether the socket should be nonblocking. False by default.
-DDV::Socket::Socket(std::string address, bool nonblock){
+Socket::Connection::Connection(std::string address, bool nonblock){
   sock = socket(PF_UNIX, SOCK_STREAM, 0);
   if (sock < 0){
     #if DEBUG >= 1
@@ -60,11 +62,11 @@ DDV::Socket::Socket(std::string address, bool nonblock){
     #endif
     close();
   }
-}//DDV::Socket Unix Contructor
+}//Socket::Connection Unix Contructor
 
 /// Returns the ready-state for this socket.
 /// \returns 1 if data is waiting to be read, -1 if not connected, 0 otherwise.
-signed int DDV::Socket::ready(){
+signed int Socket::Connection::ready(){
   if (sock < 0) return -1;
   char tmp;
   int preflags = fcntl(sock, F_GETFL, 0);
@@ -94,7 +96,7 @@ signed int DDV::Socket::ready(){
 /// The connection status is updated after every read/write attempt, when errors occur
 /// and when the socket is closed manually.
 /// \returns True if socket is connected, false otherwise.
-bool DDV::Socket::connected(){
+bool Socket::Connection::connected(){
   return (sock >= 0);
 }
 
@@ -104,7 +106,7 @@ bool DDV::Socket::connected(){
 /// \param buffer Location of the buffer to write from.
 /// \param len Amount of bytes to write.
 /// \returns True if the whole write was succesfull, false otherwise.
-bool DDV::Socket::write(const void * buffer, int len){
+bool Socket::Connection::write(const void * buffer, int len){
   int sofar = 0;
   if (sock < 0){return false;}
   while (sofar != len){
@@ -130,38 +132,52 @@ bool DDV::Socket::write(const void * buffer, int len){
 /// \param buffer Location of the buffer to read to.
 /// \param len Amount of bytes to read.
 /// \returns True if the whole read was succesfull, false otherwise.
-bool DDV::Socket::read(void * buffer, int len){
+bool Socket::Connection::read(void * buffer, int len){
   int sofar = 0;
   if (sock < 0){return false;}
   while (sofar != len){
     int r = recv(sock, (char*)buffer + sofar, len-sofar, 0);
-    if (r <= 0){
-      Error = true;
-      #if DEBUG >= 2
-      fprintf(stderr, "Could not read data! Error: %s\n", strerror(errno));
-      #endif
-      close();
+    if (r < 0){
+      switch (errno){
+        case EWOULDBLOCK: return 0; break;
+        default:
+          Error = true;
+          #if DEBUG >= 2
+          fprintf(stderr, "Could not read data! Error %i: %s\n", r, strerror(errno));
+          #endif
+          close();
+          break;
+      }
       return false;
     }else{
+      if (r == 0){
+        Error = true;
+        #if DEBUG >= 2
+        fprintf(stderr, "Could not read data! Socket is closed.\n");
+        #endif
+        close();
+        return false;
+      }
       sofar += r;
     }
   }
   return true;
-}//DDV::Socket::read
+}//Socket::Connection::read
 
 /// Read call that is compatible with file access syntax. This function simply calls the other read function.
-bool DDV::Socket::read(void * buffer, int width, int count){return read(buffer, width*count);}
+bool Socket::Connection::read(void * buffer, int width, int count){return read(buffer, width*count);}
 /// Write call that is compatible with file access syntax. This function simply calls the other write function.
-bool DDV::Socket::write(void * buffer, int width, int count){return write(buffer, width*count);}
+bool Socket::Connection::write(void * buffer, int width, int count){return write(buffer, width*count);}
 /// Write call that is compatible with std::string. This function simply calls the other write function.
-bool DDV::Socket::write(const std::string data){return write(data.c_str(), data.size());}
+bool Socket::Connection::write(const std::string data){return write(data.c_str(), data.size());}
 
 /// Incremental write call. This function tries to write len bytes to the socket from the buffer,
 /// returning the amount of bytes it actually wrote.
 /// \param buffer Location of the buffer to write from.
 /// \param len Amount of bytes to write.
 /// \returns The amount of bytes actually written.
-int DDV::Socket::iwrite(void * buffer, int len){
+int Socket::Connection::iwrite(void * buffer, int len){
+  if (sock < 0){return 0;}
   int r = send(sock, buffer, len, 0);
   if (r < 0){
     switch (errno){
@@ -178,14 +194,15 @@ int DDV::Socket::iwrite(void * buffer, int len){
   }
   if (r == 0){close();}
   return r;
-}//DDV::Socket::iwrite
+}//Socket::Connection::iwrite
 
 /// Incremental read call. This function tries to read len bytes to the buffer from the socket,
 /// returning the amount of bytes it actually read.
 /// \param buffer Location of the buffer to read to.
 /// \param len Amount of bytes to read.
 /// \returns The amount of bytes actually read.
-int DDV::Socket::iread(void * buffer, int len){
+int Socket::Connection::iread(void * buffer, int len){
+  if (sock < 0){return 0;}
   int r = recv(sock, buffer, len, 0);
   if (r < 0){
     switch (errno){
@@ -202,14 +219,14 @@ int DDV::Socket::iread(void * buffer, int len){
   }
   if (r == 0){close();}
   return r;
-}//DDV::Socket::iread
+}//Socket::Connection::iread
 
 /// Read call that is compatible with std::string.
-/// Data is read using iread (which is nonblocking if the DDV::Socket itself is),
-/// then appended to end of buffer.
+/// Data is read using iread (which is nonblocking if the Socket::Connection itself is),
+/// then appended to end of buffer. This functions reads at least one byte before returning.
 /// \param buffer std::string to append data to.
 /// \return True if new data arrived, false otherwise.
-bool DDV::Socket::read(std::string & buffer){
+bool Socket::Connection::read(std::string & buffer){
   char cbuffer[5000];
   if (!read(cbuffer, 1)){return false;}
   int num = iread(cbuffer+1, 4999);
@@ -221,19 +238,62 @@ bool DDV::Socket::read(std::string & buffer){
   return true;
 }//read
 
-/// Create a new base ServerSocket. The socket is never connected, and a placeholder for later connections.
-DDV::ServerSocket::ServerSocket(){
+/// Read call that is compatible with std::string.
+/// Data is read using iread (which is nonblocking if the Socket::Connection itself is),
+/// then appended to end of buffer.
+/// \param buffer std::string to append data to.
+/// \return True if new data arrived, false otherwise.
+bool Socket::Connection::iread(std::string & buffer){
+  char cbuffer[5000];
+  int num = iread(cbuffer, 5000);
+  if (num < 1){return false;}
+  buffer.append(cbuffer, num);
+  return true;
+}//iread
+
+/// Incremental write call that is compatible with std::string.
+/// Data is written using iwrite (which is nonblocking if the Socket::Connection itself is),
+/// then removed from front of buffer.
+/// \param buffer std::string to remove data from.
+/// \return True if more data was sent, false otherwise.
+bool Socket::Connection::iwrite(std::string & buffer){
+  if (buffer.size() < 1){return false;}
+  int tmp = iwrite((void*)buffer.c_str(), buffer.size());
+  if (tmp < 1){return false;}
+  buffer = buffer.substr(tmp);
+  return true;
+}//iwrite
+
+/// Write call that is compatible with std::string.
+/// Data is written using write (which is always blocking),
+/// then removed from front of buffer.
+/// \param buffer std::string to remove data from.
+/// \return True if more data was sent, false otherwise.
+bool Socket::Connection::swrite(std::string & buffer){
+  if (buffer.size() < 1){return false;}
+  bool tmp = write((void*)buffer.c_str(), buffer.size());
+  if (tmp){buffer = "";}
+  return tmp;
+}//write
+
+/// Gets hostname for connection, if available.
+std::string Socket::Connection::getHost(){
+  return remotehost;
+}
+
+/// Create a new base Server. The socket is never connected, and a placeholder for later connections.
+Socket::Server::Server(){
   sock = -1;
-}//DDV::ServerSocket base Constructor
+}//Socket::Server base Constructor
   
-/// Create a new TCP ServerSocket. The socket is immediately bound and set to listen.
+/// Create a new TCP Server. The socket is immediately bound and set to listen.
 /// A maximum of 100 connections will be accepted between accept() calls.
 /// Any further connections coming in will be dropped.
 /// \param port The TCP port to listen on
 /// \param hostname (optional) The interface to bind to. The default is 0.0.0.0 (all interfaces).
 /// \param nonblock (optional) Whether accept() calls will be nonblocking. Default is false (blocking).
-DDV::ServerSocket::ServerSocket(int port, std::string hostname, bool nonblock){
-  sock = socket(AF_INET, SOCK_STREAM, 0);
+Socket::Server::Server(int port, std::string hostname, bool nonblock){
+  sock = socket(AF_INET6, SOCK_STREAM, 0);
   if (sock < 0){
     #if DEBUG >= 1
     fprintf(stderr, "Could not create socket! Error: %s\n", strerror(errno));
@@ -247,10 +307,14 @@ DDV::ServerSocket::ServerSocket(int port, std::string hostname, bool nonblock){
     flags |= O_NONBLOCK;
     fcntl(sock, F_SETFL, flags);
   }
-  struct sockaddr_in addr;
-  addr.sin_family = AF_INET;
-  addr.sin_port = htons(port);//set port
-  inet_pton(AF_INET, hostname.c_str(), &addr.sin_addr);//set interface, 0.0.0.0 (default) is all
+  struct sockaddr_in6 addr;
+  addr.sin6_family = AF_INET6;
+  addr.sin6_port = htons(port);//set port
+  if (hostname == "0.0.0.0"){
+    addr.sin6_addr = in6addr_any;
+  }else{
+    inet_pton(AF_INET6, hostname.c_str(), &addr.sin6_addr);//set interface, 0.0.0.0 (default) is all
+  }
   int ret = bind(sock, (sockaddr*)&addr, sizeof(addr));//do the actual bind
   if (ret == 0){
     ret = listen(sock, 100);//start listening, backlog of 100 allowed
@@ -270,15 +334,15 @@ DDV::ServerSocket::ServerSocket(int port, std::string hostname, bool nonblock){
     close();
     return;
   }
-}//DDV::ServerSocket TCP Constructor
+}//Socket::Server TCP Constructor
 
-/// Create a new Unix ServerSocket. The socket is immediately bound and set to listen.
+/// Create a new Unix Server. The socket is immediately bound and set to listen.
 /// A maximum of 100 connections will be accepted between accept() calls.
 /// Any further connections coming in will be dropped.
 /// The address used will first be unlinked - so it succeeds if the Unix socket already existed. Watch out for this behaviour - it will delete any file located at address!
 /// \param address The location of the Unix socket to bind to.
 /// \param nonblock (optional) Whether accept() calls will be nonblocking. Default is false (blocking).
-DDV::ServerSocket::ServerSocket(std::string address, bool nonblock){
+Socket::Server::Server(std::string address, bool nonblock){
   unlink(address.c_str());
   sock = socket(AF_UNIX, SOCK_STREAM, 0);
   if (sock < 0){
@@ -314,15 +378,18 @@ DDV::ServerSocket::ServerSocket(std::string address, bool nonblock){
     close();
     return;
   }
-}//DDV::ServerSocket Unix Constructor
+}//Socket::Server Unix Constructor
 
-/// Accept any waiting connections. If the DDV::ServerSocket is blocking, this function will block until there is an incoming connection.
-/// If the DDV::ServerSocket is nonblocking, it might return a DDV::Socket that is not connected, so check for this.
+/// Accept any waiting connections. If the Socket::Server is blocking, this function will block until there is an incoming connection.
+/// If the Socket::Server is nonblocking, it might return a Socket::Connection that is not connected, so check for this.
 /// \param nonblock (optional) Whether the newly connected socket should be nonblocking. Default is false (blocking).
-/// \returns A DDV::Socket, which may or may not be connected, depending on settings and circumstances.
-DDV::Socket DDV::ServerSocket::accept(bool nonblock){
-  if (sock < 0){return DDV::Socket(-1);}
-  int r = ::accept(sock, 0, 0);
+/// \returns A Socket::Connection, which may or may not be connected, depending on settings and circumstances.
+Socket::Connection Socket::Server::accept(bool nonblock){
+  if (sock < 0){return Socket::Connection(-1);}
+  struct sockaddr_in6 addrinfo;
+  socklen_t len = sizeof(addrinfo);
+  static char addrconv[INET6_ADDRSTRLEN];
+  int r = ::accept(sock, (sockaddr*)&addrinfo, &len);
   //set the socket to be nonblocking, if requested.
   //we could do this through accept4 with a flag, but that call is non-standard...
   if ((r >= 0) && nonblock){
@@ -330,26 +397,48 @@ DDV::Socket DDV::ServerSocket::accept(bool nonblock){
     flags |= O_NONBLOCK;
     fcntl(r, F_SETFL, flags);
   }
+  Socket::Connection tmp(r);
   if (r < 0){
     if (errno != EWOULDBLOCK && errno != EAGAIN){close();}
+  }else{
+    if (addrinfo.sin6_family == AF_INET6){
+      tmp.remotehost = inet_ntop(AF_INET6, &(addrinfo.sin6_addr), addrconv, INET6_ADDRSTRLEN);
+      #if DEBUG >= 4
+      printf("IPv6 addr: %s\n", tmp.remotehost.c_str());
+      #endif
+    }
+    if (addrinfo.sin6_family == AF_INET){
+      tmp.remotehost = inet_ntop(AF_INET, &(((sockaddr_in*)&addrinfo)->sin_addr), addrconv, INET6_ADDRSTRLEN);
+      #if DEBUG >= 4
+      printf("IPv4 addr: %s\n", tmp.remotehost.c_str());
+      #endif
+    }
+    if (addrinfo.sin6_family == AF_UNIX){
+      #if DEBUG >= 4
+      tmp.remotehost = ((sockaddr_un*)&addrinfo)->sun_path;
+      printf("Unix addr: %s\n", tmp.remotehost.c_str());
+      #endif
+      tmp.remotehost = "UNIX_SOCKET";
+    }
   }
-  return DDV::Socket(r);
+  return tmp;
 }
 
 /// Close connection. The internal socket is closed and then set to -1.
-void DDV::ServerSocket::close(){
+void Socket::Server::close(){
+  shutdown(sock, SHUT_RDWR);
   ::close(sock);
   sock = -1;
-}//DDV::ServerSocket::close
+}//Socket::Server::close
 
 /// Returns the connected-state for this socket.
 /// Note that this function might be slightly behind the real situation.
 /// The connection status is updated after every accept attempt, when errors occur
 /// and when the socket is closed manually.
 /// \returns True if socket is connected, false otherwise.
-bool DDV::ServerSocket::connected(){
+bool Socket::Server::connected(){
   return (sock >= 0);
-}//DDV::ServerSocket::connected
+}//Socket::Server::connected
 
 /// Returns internal socket number.
-int DDV::ServerSocket::getSocket(){return sock;}
+int Socket::Server::getSocket(){return sock;}

util/socket.h

@@ -1,5 +1,6 @@
-/// \file ddv_socket.h
-/// Holds all headers for the DDV namespace.
+/// \file socket.h
+/// A handy Socket wrapper library.
+/// Written by Jaron Vietor in 2010 for DDVTech
 
 #pragma once
 #include <string>
@@ -14,17 +15,18 @@
 #include <fcntl.h>
 
 
-///Holds DDV Socket tools.
-namespace DDV{
+///Holds Socket tools.
+namespace Socket{
 
   /// This class is for easy communicating through sockets, either TCP or Unix.
-  class Socket{
+  class Connection{
     private:
       int sock; ///< Internally saved socket number.
+      std::string remotehost; ///< Stores remote host address.
     public:
-      Socket(); ///< Create a new disconnected base socket.
-      Socket(int sockNo); ///< Create a new base socket.
-      Socket(std::string adres, bool nonblock = false); ///< Create a new Unix Socket.
+      Connection(); ///< Create a new disconnected base socket.
+      Connection(int sockNo); ///< Create a new base socket.
+      Connection(std::string adres, bool nonblock = false); ///< Create a new Unix Socket.
       bool Error; ///< Set to true if a socket error happened.
       bool Blocking; ///< Set to true if a socket is currently or wants to be blocking.
       signed int ready(); ///< Returns the ready-state for this socket.
@@ -37,19 +39,24 @@ namespace DDV{
       int iwrite(void * buffer, int len); ///< Incremental write call.
       int iread(void * buffer, int len); ///< Incremental read call.
       bool read(std::string & buffer); ///< Read call that is compatible with std::string.
+      bool swrite(std::string & buffer); ///< Read call that is compatible with std::string.
+      bool iread(std::string & buffer); ///< Incremental write call that is compatible with std::string.
+      bool iwrite(std::string & buffer); ///< Write call that is compatible with std::string.
       void close(); ///< Close connection.
+      std::string getHost(); ///< Gets hostname for connection, if available.
       int getSocket(); ///< Returns internal socket number.
+      friend class Server;
   };
 
   /// This class is for easily setting up listening socket, either TCP or Unix.
-  class ServerSocket{
+  class Server{
     private:
       int sock; ///< Internally saved socket number.
     public:
-      ServerSocket(); ///< Create a new base ServerSocket.
-      ServerSocket(int port, std::string hostname = "0.0.0.0", bool nonblock = false); ///< Create a new TCP ServerSocket.
-      ServerSocket(std::string adres, bool nonblock = false); ///< Create a new Unix ServerSocket.
-      Socket accept(bool nonblock = false); ///< Accept any waiting connections.
+      Server(); ///< Create a new base Server.
+      Server(int port, std::string hostname = "0.0.0.0", bool nonblock = false); ///< Create a new TCP Server.
+      Server(std::string adres, bool nonblock = false); ///< Create a new Unix Server.
+      Connection accept(bool nonblock = false); ///< Accept any waiting connections.
       bool connected(); ///< Returns the connected-state for this socket.
       void close(); ///< Close connection.
       int getSocket(); ///< Returns internal socket number.