Encode / Decode URLs em C ++

Alguém sabe de algum código C ++ bom que faz isso?

Eu enfrentei a metade da codificação deste problema no outro dia. Infeliz com as opções disponíveis, e depois de dar uma olhada neste código de exemplo C , decidi rodar minha própria function de codificação de URL C ++:

#include  #include  #include  #include  using namespace std; string url_encode(const string &value) { ostringstream escaped; escaped.fill('0'); escaped < < hex; for (string::const_iterator i = value.begin(), n = value.end(); i != n; ++i) { string::value_type c = (*i); // Keep alphanumeric and other accepted characters intact if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') { escaped << c; continue; } // Any other characters are percent-encoded escaped << uppercase; escaped << '%' << setw(2) << int((unsigned char) c); escaped << nouppercase; } return escaped.str(); } 

A implementação da function de decodificação é deixada como um exercício para o leitor. : P

Respondendo minha própria pergunta …

libcurl tem curl_easy_escape para codificação.

Para decodificação, curl_easy_unescape

 string urlDecode(string &SRC) { string ret; char ch; int i, ii; for (i=0; i(ii); ret+=ch; i=i+2; } else { ret+=SRC[i]; } } return (ret); } 

não é o melhor, mas funciona bem 😉

E código fonte …

http://www.codeguru.com/cpp/cpp/string/conversions/article.php/c12759

O corpo deve ter pelo menos 30 caracteres

cpp-netlib tem funções

 namespace boost { namespace network { namespace uri { inline std::string decoded(const std::string &input); inline std::string encoded(const std::string &input); } } } 

eles permitem codificar e decodificar strings de URL muito facilmente.

Geralmente, adicionar ‘%’ ao valor int de um caractere não funcionará durante a codificação, o valor é suposto para o equivalente hexadecimal. eg ‘/’ é ‘% 2F’ não ‘% 47’.

Eu acho que esta é a melhor e concisa soluções para ambos os codificação e decodificação de url (Não há muito dependencies de header).

 string urlEncode(string str){ string new_str = ""; char c; int ic; const char* chars = str.c_str(); char bufHex[10]; int len = strlen(chars); for(int i=0;i(ii); ret += ch; i = i + 2; } } return ret; } 

O CGICC inclui methods para fazer codificação e decodificação de url. form_urlencode e form_urldecode

[Modo Necromancer on]
Tropeçou nesta questão quando estava à procura de solução rápida, moderna, independente de plataforma e elegante. Não gostei de nenhum dos acima, cpp-netlib seria o vencedor, mas tem vulnerabilidade de memory horrível na function “decodificada”. Então eu criei a solução de qi / karma do spirit.

 namespace bsq = boost::spirit::qi; namespace bk = boost::spirit::karma; bsq::int_parser hex_byte; template  struct unescaped_string : bsq::grammar { unescaped_string() : unescaped_string::base_type(unesc_str) { unesc_char.add("+", ' '); unesc_str = *(unesc_char | "%" >> hex_byte | bsq::char_); } bsq::rule unesc_str; bsq::symbols unesc_char; }; template  struct escaped_string : bk::grammar { escaped_string() : escaped_string::base_type(esc_str) { esc_str = *(bk::char_("a-zA-Z0-9_.~-") | "%" < < bk::right_align(2,0)[bk::hex]); } bk::rule esc_str; }; 

O uso de acima da seguinte forma:

 std::string unescape(const std::string &input) { std::string retVal; retVal.reserve(input.size()); typedef std::string::const_iterator iterator_type; char const *start = ""; iterator_type beg = input.begin(); iterator_type end = input.end(); unescaped_string p; if (!bsq::parse(beg, end, p(start), retVal)) retVal = input; return retVal; } std::string escape(const std::string &input) { typedef std::back_insert_iterator sink_type; std::string retVal; retVal.reserve(input.size() * 3); sink_type sink(retVal); char const *start = ""; escaped_string g; if (!bk::generate(sink, g(start), input)) retVal = input; return retVal; } 

[Modo Necromancer off]

EDIT01: corrigido o material de preenchimento de zero – um agradecimento especial a Hartmut Kaiser
EDIT02: ao vivo no CoLiRu

O algoritmo de codificação / decodificação de URL não é tão difícil.

Eu começaria da especificação:

Codificação Url na Wikipedia

Se você quiser código pré-cozinhado, basta procurar os Internets:

http://www.google.it/search?hl=it&q=Encode+Decode+URLs+in+C%2B%2B&meta=

(Sim, esse endereço é codificado por url)

Inspirado por xperroni eu escrevi um decodificador. Obrigado pelo ponteiro.

 #include  #include  #include  using namespace std; char from_hex(char ch) { return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10; } string url_decode(string text) { char h; ostringstream escaped; escaped.fill('0'); for (auto i = text.begin(), n = text.end(); i != n; ++i) { string::value_type c = (*i); if (c == '%') { if (i[1] && i[2]) { h = from_hex(i[1]) < < 4 | from_hex(i[2]); escaped << h; i += 2; } } else if (c == '+') { escaped << ' '; } else { escaped << c; } } return escaped.str(); } int main(int argc, char** argv) { string msg = "J%C3%B8rn!"; cout << msg << endl; string decodemsg = url_decode(msg); cout << decodemsg << endl; return 0; } 

edit: cctype e iomainip desnecessários foram incluídos.

Adicionando um follow-up à recomendação de Bill para usar o libcurl: great suggestion, e para ser atualizado:
depois de 3 anos, a function curl_escape é obsoleta, portanto, para uso futuro, é melhor usar curl_easy_escape .

Eu acabei nessa pergunta ao procurar por uma API para decodificar url em um aplicativo win32 c ++. Já que a questão não especifica a plataforma, assumir o Windows não é uma coisa ruim.

InternetCanonicalizeUrl é a API para programas do Windows. Mais informação aqui

  LPTSTR lpOutputBuffer = new TCHAR[1]; DWORD dwSize = 1; BOOL fRes = ::InternetCanonicalizeUrl(strUrl, lpOutputBuffer, &dwSize, ICU_DECODE | ICU_NO_ENCODE); DWORD dwError = ::GetLastError(); if (!fRes && dwError == ERROR_INSUFFICIENT_BUFFER) { delete lpOutputBuffer; lpOutputBuffer = new TCHAR[dwSize]; fRes = ::InternetCanonicalizeUrl(strUrl, lpOutputBuffer, &dwSize, ICU_DECODE | ICU_NO_ENCODE); if (fRes) { //lpOutputBuffer has decoded url } else { //failed to decode } if (lpOutputBuffer !=NULL) { delete [] lpOutputBuffer; lpOutputBuffer = NULL; } } else { //some other error OR the input string url is just 1 char and was successfully decoded } 

InternetCrackUrl ( aqui ) também parece ter sinalizadores para especificar se deseja decodificar o URL

Não consegui encontrar um URI decode / unescape aqui que também decodifique seqüências de 2 e 3 bytes. Contribuindo com a minha própria versão de alto desempenho, que on-the-fly converte a input c sting para um wstring:

 #include  const char HEX2DEC[55] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1, -1,-1,-1,-1, -1,10,11,12, 13,14,15,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,10,11,12, 13,14,15 }; #define __x2d__(s) HEX2DEC[*(s)-48] #define __x2d2__(s) __x2d__(s) < < 4 | __x2d__(s+1) std::wstring decodeURI(const char * s) { unsigned char b; std::wstring ws; while (*s) { if (*s == '%') if ((b = __x2d2__(s + 1)) >= 0x80) { if (b >= 0xE0) { // three byte codepoint ws += ((b & 0b00001111) < < 12) | ((__x2d2__(s + 4) & 0b00111111) << 6) | (__x2d2__(s + 7) & 0b00111111); s += 9; } else { // two byte codepoint ws += (__x2d2__(s + 4) & 0b00111111) | (b & 0b00000011) << 6; s += 6; } } else { // one byte codepoints ws += b; s += 3; } else { // no % ws += *s; s++; } } return ws; } 

A API do Windows tem as funções UrlEscape / UrlUnescape , exportadas por shlwapi.dll, para essa tarefa.

Esta versão é pura C e pode, opcionalmente, normalizar o caminho do recurso. Usá-lo com o C ++ é trivial:

 #include  #include  int main(int argc, char** argv) { const std::string src("/some.url/foo/../bar/%2e/"); std::cout < < "src=\"" << src << "\"" << std::endl; // either do it the C++ conformant way: char* dst_buf = new char[src.size() + 1]; urldecode(dst_buf, src.c_str(), 1); std::string dst1(dst_buf); delete[] dst_buf; std::cout << "dst1=\"" << dst1 << "\"" << std::endl; // or in-place with the &[0] trick to skip the new/delete std::string dst2; dst2.resize(src.size() + 1); dst2.resize(urldecode(&dst2[0], src.c_str(), 1)); std::cout << "dst2=\"" << dst2 << "\"" << std::endl; } 

Saídas:

 src="/some.url/foo/../bar/%2e/" dst1="/some.url/bar/" dst2="/some.url/bar/" 

E a function real:

 #include  #include  /** * decode a percent-encoded C string with optional path normalization * * The buffer pointed to by @dst must be at least strlen(@src) bytes. * Decoding stops at the first character from @src that decodes to null. * Path normalization will remove redundant slashes and slash+dot sequences, * as well as removing path components when slash+dot+dot is found. It will * keep the root slash (if one was present) and will stop normalization * at the first questionmark found (so query parameters won't be normalized). * * @param dst destination buffer * @param src source buffer * @param normalize perform path normalization if nonzero * @return number of valid characters in @dst * @author Johan Lindh  * @legalese BSD licensed (http://opensource.org/licenses/BSD-2-Clause) */ ptrdiff_t urldecode(char* dst, const char* src, int normalize) { char* org_dst = dst; int slash_dot_dot = 0; char ch, a, b; do { ch = *src++; if (ch == '%' && isxdigit(a = src[0]) && isxdigit(b = src[1])) { if (a < 'A') a -= '0'; else if(a < 'a') a -= 'A' - 10; else a -= 'a' - 10; if (b < 'A') b -= '0'; else if(b < 'a') b -= 'A' - 10; else b -= 'a' - 10; ch = 16 * a + b; src += 2; } if (normalize) { switch (ch) { case '/': if (slash_dot_dot < 3) { /* compress consecutive slashes and remove slash-dot */ dst -= slash_dot_dot; slash_dot_dot = 1; break; } /* fall-through */ case '?': /* at start of query, stop normalizing */ if (ch == '?') normalize = 0; /* fall-through */ case '\0': if (slash_dot_dot > 1) { /* remove trailing slash-dot-(dot) */ dst -= slash_dot_dot; /* remove parent directory if it was two dots */ if (slash_dot_dot == 3) while (dst > org_dst && *--dst != '/') /* empty body */; slash_dot_dot = (ch == '/') ? 1 : 0; /* keep the root slash if any */ if (!slash_dot_dot && dst == org_dst && *dst == '/') ++dst; } break; case '.': if (slash_dot_dot == 1 || slash_dot_dot == 2) { ++slash_dot_dot; break; } /* fall-through */ default: slash_dot_dot = 0; } } *dst++ = ch; } while(ch); return (dst - org_dst) - 1; } 

os pedaços suculentos

 #include  // isdigit, tolower from_hex(char ch) { return isdigit(ch) ? ch - '0' : tolower(ch) - 'a' + 10; } char to_hex(char code) { static char hex[] = "0123456789abcdef"; return hex[code & 15]; } 

notar que

 char d = from_hex(hex[0]) < < 4 | from_hex(hex[1]); 

como em

 // %7B = '{' char d = from_hex('7') < < 4 | from_hex('B'); 

Você pode usar a function “g_uri_escape_string ()” fornecida glib.h. https://developer.gnome.org/glib/stable/glib-URI-Functions.html

 #include  #include  #include  int main() { char *uri = "http://www.example.com?hello world"; char *encoded_uri = NULL; //as per wiki (https://en.wikipedia.org/wiki/Percent-encoding) char *escape_char_str = "!*'();:@&=+$,/?#[]"; encoded_uri = g_uri_escape_string(uri, escape_char_str, TRUE); printf("[%s]\n", encoded_uri); free(encoded_uri); return 0; } 

compilar com:

 gcc encoding_URI.c `pkg-config --cflags --libs glib-2.0` 

Outra solução está disponível usando a biblioteca folly::uriEscape do Facebook : folly::uriEscape e folly::uriUnescape .

você pode simplesmente usar a function AtlEscapeUrl () em atlutil.h, apenas leia sua documentação sobre como usá-la.

Tive que fazer isso em um projeto sem Boost. Então, acabei escrevendo o meu próprio. Vou apenas colocá-lo no GitHub: https://github.com/corporateshark/LUrlParser

 clParseURL URL = clParseURL::ParseURL( "https://name:pwd@github.com:80/path/res" ); if ( URL.IsValid() ) { cout < < "Scheme : " << URL.m_Scheme << endl; cout << "Host : " << URL.m_Host << endl; cout << "Port : " << URL.m_Port << endl; cout << "Path : " << URL.m_Path << endl; cout << "Query : " << URL.m_Query << endl; cout << "Fragment : " << URL.m_Fragment << endl; cout << "User name : " << URL.m_UserName << endl; cout << "Password : " << URL.m_Password << endl; } 

Eu sei que a questão pede um método C ++, mas para aqueles que podem precisar, eu criei uma function muito curta em C simples para codificar uma string. Ele não cria uma nova string, mas altera a existente, o que significa que ela deve ter tamanho suficiente para conter a nova string. Muito fácil de acompanhar.

 void urlEncode(char *string) { char charToEncode; int posToEncode; while (((posToEncode=strspn(string,"1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_.~"))!=0) &&(posToEncode>4]; string[posToEncode+2]="0123456789ABCDEF"[charToEncode&0xf]; string+=posToEncode+3; } }