diff --git a/util/amf.cpp b/util/amf.cpp index b82aceeb..b5f51fad 100644 --- a/util/amf.cpp +++ b/util/amf.cpp @@ -2,6 +2,7 @@ /// Holds all code for the AMF namespace. #include "amf.h" +#include //needed for stderr only /// Returns the std::string Indice for the current object, if available. /// Returns an empty string if no indice exists. diff --git a/util/flv_tag.cpp b/util/flv_tag.cpp index 02494b56..140183f3 100644 --- a/util/flv_tag.cpp +++ b/util/flv_tag.cpp @@ -7,7 +7,6 @@ #include //for Tag::FileLoader #include //malloc #include //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. diff --git a/util/flv_tag.h b/util/flv_tag.h index 0ba13ea5..74d0ffa7 100644 --- a/util/flv_tag.h +++ b/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 /// 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 diff --git a/util/http_parser.cpp b/util/http_parser.cpp index 4fe7b94f..ec648a39 100644 --- a/util/http_parser.cpp +++ b/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; diff --git a/util/http_parser.h b/util/http_parser.h index ed8f64fe..d7048eae 100644 --- a/util/http_parser.h +++ b/util/http_parser.h @@ -6,7 +6,7 @@ #include #include #include -#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; diff --git a/util/rtmpchunks.cpp b/util/rtmpchunks.cpp index a63a2380..9ab9aaa7 100644 --- a/util/rtmpchunks.cpp +++ b/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; diff --git a/util/server_setup.cpp b/util/server_setup.cpp index 36e09c47..20d8c4f5 100644 --- a/util/server_setup.cpp +++ b/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 #include #include #include #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 diff --git a/util/ddv_socket.cpp b/util/socket.cpp similarity index 61% rename from util/ddv_socket.cpp rename to util/socket.cpp index 72ed286e..60c3c69e 100644 --- a/util/ddv_socket.cpp +++ b/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;} diff --git a/util/ddv_socket.h b/util/socket.h similarity index 60% rename from util/ddv_socket.h rename to util/socket.h index 5d58e0bd..2b982563 100644 --- a/util/ddv_socket.h +++ b/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 @@ -14,17 +15,18 @@ #include -///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.