const std::string& str,

const char separator

)

{

return string_utilities::string_split(str, separator);

{

std::string n_url = url;

std::string::iterator new_end = std::unique(n_url.begin(), n_url.end(), [](char a, char b) { return (a == b) && (a == '/'); });

n_url.erase(new_end, n_url.end());

std::string::size_type n_url_length = n_url.length();

std::string result;

if (n_url_length > 1 && n_url[n_url_length - 1] == '/')

{

result = n_url.substr(0, n_url_length - 1);

}

else

{

result = n_url;

}

return result;

{

if (!sa) throw std::invalid_argument("socket pointer is null");

char to_ret[NI_MAXHOST];

if (AF_INET6 == sa->sa_family)

{

inet_ntop(AF_INET6, &(((sockaddr_in6*) sa)->sin6_addr), to_ret, INET6_ADDRSTRLEN);

return to_ret;

}

else if (AF_INET == sa->sa_family)

{

inet_ntop(AF_INET, &(((sockaddr_in*) sa)->sin_addr), to_ret, INET_ADDRSTRLEN);

return to_ret;

}

else

{

throw std::invalid_argument("IP family must be either AF_INET or AF_INET6");

}

{

if (!sa) throw std::invalid_argument("socket pointer is null");

if (sa->sa_family == AF_INET)

{

return ((struct sockaddr_in*) sa)->sin_port;

}

else if (sa->sa_family == AF_INET6)

{

return ((struct sockaddr_in6*) sa)->sin6_port;

}

else

{

throw std::invalid_argument("IP family must be either AF_INET or AF_INET6");

}

{

if (val.empty()) return 0;

int rpos = 0;

int wpos = 0;

unsigned int num;

while ('\0' != val[rpos])

{

switch (val[rpos])

{

case '+':

val[wpos] = ' ';

wpos++;

rpos++;

break;

case '%':

if ( (1 == sscanf (val.substr(rpos + 1).c_str(), "%2x", &num)) ||

(1 == sscanf (val.substr(rpos + 1).c_str(), "%2X", &num))

)

{

val[wpos] = (unsigned char) num;

wpos++;

rpos += 3;

break;

}

/* intentional fall through! */

default:

val[wpos] = val[rpos];

wpos++;

rpos++;

}

}

val[wpos] = '\0'; /* add 0-terminator */

val.resize(wpos);

return wpos; /* = strlen(val) */

{

std::fill(pieces, pieces + 16, 0);

if(ip->sa_family == AF_INET)

{

ip_version = http_utils::IPV4;

for(int i=0;i<4;i++)

{

pieces[12+i]=((u_char*)&(((struct sockaddr_in *)ip)->sin_addr))[i];

}

}

else

{

ip_version = http_utils::IPV6;

for (int i = 0; i < 16; i++)

{

pieces[i] = ((u_char*)&(((struct sockaddr_in6 *)ip)->sin6_addr))[i];

}

}

mask = DEFAULT_MASK_VALUE;

{

std::vector<std::string> parts;

mask = DEFAULT_MASK_VALUE;

std::fill(pieces, pieces + 16, 0);

if(ip.find(':') != std::string::npos) //IPV6

{

ip_version = http_utils::IPV6;

parts = string_utilities::string_split(ip, ':', false);

if (parts.size() > 8)

{

throw std::invalid_argument("IP is badly formatted. Max 8 parts in IPV6.");

}

unsigned int omitted = 8 - (parts.size() - 1);

if (omitted != 0)

{

int empty_count = 0;

for (unsigned int i = 0; i < parts.size(); i++)

{

if (parts[i].size() == 0) empty_count++;

}

if (empty_count > 1)

{

if (parts[parts.size() - 1].find(".") != std::string::npos) omitted -= 1;

if (empty_count == 2 && parts[0] == "" && parts[1] == "")

{

omitted += 1;

parts = std::vector<std::string>(parts.begin() + 1, parts.end());

}

else

{

throw std::invalid_argument("IP is badly formatted. Cannot have more than one omitted segment in IPV6.");

}

}

}

int y = 0;

for (unsigned int i = 0; i < parts.size(); i++)

{

if (parts[i] != "*")

{

if (parts[i].size() == 0)

{

for (unsigned int omitted_idx = 0; omitted_idx < omitted; omitted_idx++)

{

pieces[y] = 0;

pieces[y+1] = 0;

y += 2;

}

continue;

}

if (parts[i].size() < 4)

{

stringstream ss;

ss << setfill('0') << setw(4) << parts[i];

parts[i] = ss.str();

}

if (parts[i].size() == 4)

{

pieces[y] = strtol((parts[i].substr(0,2)).c_str(),NULL,16);

pieces[y+1] = strtol(

(parts[i].substr(2,2)).c_str(),

NULL,

16

);

y += 2;

}

else

{

if(parts[i].find('.') != std::string::npos)

{

if(y != 12)

{

throw std::invalid_argument("IP is badly formatted. Missing parts before nested IPV4.");

}

if (i != parts.size() - 1)

{

throw std::invalid_argument("IP is badly formatted. Nested IPV4 should be at the end");

}

vector<string> subparts = string_utilities::string_split(parts[i], '.');

if(subparts.size() == 4)

{

for (unsigned int k = 0; k < 10; k++)

{

if (pieces[k] != 0) throw std::invalid_argument("IP is badly formatted. Nested IPV4 can be preceded only by 0 (and, optionally, two 255 octects)");

}

if ((pieces[10] != 0 && pieces[10] != 255) || (pieces[11] != 0 && pieces[11] != 255))

{

throw std::invalid_argument("IP is badly formatted. Nested IPV4 can be preceded only by 0 (and, optionally, two 255 octects)");

}

for(unsigned int ii = 0; ii < subparts.size(); ii++)

{

if(subparts[ii] != "*")

{

pieces[y+ii] = strtol(

subparts[ii].c_str(),

NULL,

10

);

if (pieces[y+ii] > 255) throw std::invalid_argument("IP is badly formatted. 255 is max value for ip part.");

}

else

{

CLEAR_BIT(mask, y+ii);

}

}

}

else

{

throw std::invalid_argument("IP is badly formatted. Nested IPV4 can have max 4 parts.");

}

}

else

{

throw std::invalid_argument("IP is badly formatted. IPV6 parts can have max 4 characters (or nest an IPV4)");

}

}

}

else

{

CLEAR_BIT(mask, y);

CLEAR_BIT(mask, y+1);

y+=2;

}

}

}

else //IPV4

{

ip_version = http_utils::IPV4;

parts = string_utilities::string_split(ip, '.');

if(parts.size() == 4)

{

for(unsigned int i = 0; i < parts.size(); i++)

{

if(parts[i] != "*")

{

pieces[12+i] = strtol(parts[i].c_str(), NULL, 10);

if (pieces[12+i] > 255) throw std::invalid_argument("IP is badly formatted. 255 is max value for ip part.");

}

else

{

CLEAR_BIT(mask, 12+i);

}

}

}

else

{

throw std::invalid_argument("IP is badly formatted. Max 4 parts in IPV4.");

}

}

{

ifstream fp(filename.c_str(), ios::in | ios::binary | ios::ate);

if(fp.is_open())

{

std::string content;

fp.seekg(0, fp.end);

content.reserve(fp.tellg());

fp.seekg(0, fp.beg);

content.assign((std::istreambuf_iterator<char>(fp)), std::istreambuf_iterator<char>());

return content;

}

else

{

throw std::invalid_argument("Unable to open file");

}

const std::map<std::string,std::string,header_comparator> &map)

{

std::map<std::string,std::string,header_comparator>::const_iterator it = map.begin();

std::map<std::string,std::string,header_comparator>::const_iterator end = map.end();

if (map.size()) {

os << " " << prefix << " [";

for (; it != end; ++it) {

os << (*it).first << ":\"" << (*it).second << "\" ";

}

os << "]" << std::endl;

}

const std::map<std::string,std::string,arg_comparator> &map)

{

std::map<std::string,std::string,arg_comparator>::const_iterator it = map.begin();

std::map<std::string,std::string,arg_comparator>::const_iterator end = map.end();

if (map.size()) {

os << " " << prefix << " [";

for (; it != end; ++it) {

os << (*it).first << ":\"" << (*it).second << "\" ";

}

os << "]" << std::endl;

}