C ++ में URL को एनकोड / डिकोड करें [बंद]

Question 1

बन्द है। यह प्रश्न स्टैक ओवरफ्लो दिशानिर्देशों को पूरा नहीं करता है । यह वर्तमान में उत्तर स्वीकार नहीं कर रहा है।

इस प्रश्न को सुधारना चाहते हैं? सवाल को अपडेट करें ताकि यह स्टैक ओवरफ्लो के लिए विषय पर हो ।

1 साल पहले बंद हुआ ।

क्या किसी को भी किसी भी अच्छे C ++ कोड का पता है जो ऐसा करता है?

Question 2

मैंने दूसरे दिन इस समस्या के आधे एन्कोडिंग का सामना किया। उपलब्ध विकल्पों से नाखुश हैं, और इस सी नमूना कोड पर एक नज़र डालने के बाद , मैंने अपना खुद का C ++ url-encode फ़ंक्शन रोल करने का निर्णय लिया:

#include <cctype>
#include <iomanip>
#include <sstream>
#include <string>

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();
}

डिकोड फ़ंक्शन का कार्यान्वयन पाठक को एक अभ्यास के रूप में छोड़ दिया जाता है। : पी

Question 3

मेरे अपने प्रश्न का उत्तर दे रहा है ...

libcurl में curl_easy_escape हैएन्कोडिंग के लिए है।

डिकोडिंग के लिए, curl_easy_unescape

Question 4

string urlDecode(string &SRC) {
    string ret;
    char ch;
    int i, ii;
    for (i=0; i<SRC.length(); i++) {
        if (int(SRC[i])==37) {
            sscanf(SRC.substr(i+1,2).c_str(), "%x", &ii);
            ch=static_cast<char>(ii);
            ret+=ch;
            i=i+2;
        } else {
            ret+=SRC[i];
        }
    }
    return (ret);
}

सबसे अच्छा नहीं है, लेकिन ठीक काम ;-)

Question 5

cpp-netlib में फ़ंक्शंस हैं

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

वे URL स्ट्रिंग्स को एन्कोड और डिकोड करने की अनुमति देते हैं।

Question 6

सामान्य रूप से एन्कोडिंग करते समय किसी चार्ट के इंट वैल्यू में '%' जोड़ने से काम नहीं चलेगा, मान को हेक्स के बराबर माना जाता है। उदाहरण के लिए '/' '% 2F' है '% 47' नहीं।

मुझे लगता है कि यह यूआरएल एन्कोडिंग और डिकोडिंग (ज्यादा हेडर निर्भरता नहीं) दोनों के लिए सबसे अच्छा और संक्षिप्त समाधान है।

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<len;i++){
        c = chars[i];
        ic = c;
        // uncomment this if you want to encode spaces with +
        /*if (c==' ') new_str += '+';   
        else */if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') new_str += c;
        else {
            sprintf(bufHex,"%X",c);
            if(ic < 16) 
                new_str += "%0"; 
            else
                new_str += "%";
            new_str += bufHex;
        }
    }
    return new_str;
 }

string urlDecode(string str){
    string ret;
    char ch;
    int i, ii, len = str.length();

    for (i=0; i < len; i++){
        if(str[i] != '%'){
            if(str[i] == '+')
                ret += ' ';
            else
                ret += str[i];
        }else{
            sscanf(str.substr(i + 1, 2).c_str(), "%x", &ii);
            ch = static_cast<char>(ii);
            ret += ch;
            i = i + 2;
        }
    }
    return ret;
}

Question 7

[नेक्रोमैंसर मोड ऑन]
इस सवाल पर अड़ गया, जब तेज, आधुनिक, मंच स्वतंत्र और सुरुचिपूर्ण समाधान की तलाश में था। उपर्युक्त में से किसी की तरह, cpp-netlib विजेता नहीं होगा, लेकिन इसमें "डिकोडेड" फ़ंक्शन में स्मृति भेद्यता है। इसलिए मैं बूस्ट की भावना क्यूई / कर्म समाधान के साथ आया।

namespace bsq = boost::spirit::qi;
namespace bk = boost::spirit::karma;
bsq::int_parser<unsigned char, 16, 2, 2> hex_byte;
template <typename InputIterator>
struct unescaped_string
    : bsq::grammar<InputIterator, std::string(char const *)> {
  unescaped_string() : unescaped_string::base_type(unesc_str) {
    unesc_char.add("+", ' ');

    unesc_str = *(unesc_char | "%" >> hex_byte | bsq::char_);
  }

  bsq::rule<InputIterator, std::string(char const *)> unesc_str;
  bsq::symbols<char const, char const> unesc_char;
};

template <typename OutputIterator>
struct escaped_string : bk::grammar<OutputIterator, std::string(char const *)> {
  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<OutputIterator, std::string(char const *)> esc_str;
};

उपरोक्त का उपयोग निम्नानुसार है:

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<iterator_type> 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<std::string> sink_type;
  std::string retVal;
  retVal.reserve(input.size() * 3);
  sink_type sink(retVal);
  char const *start = "";

  escaped_string<sink_type> g;
  if (!bk::generate(sink, g(start), input))
    retVal = input;
  return retVal;
}

[नेक्रोमैंसर मोड बंद]

EDIT01: शून्य पैडिंग सामान तय किया - हार्टमुट कैसर
EDIT02 के लिए विशेष धन्यवाद : CoLiRu पर लाइव

Question 8

CGICC में url encode और decode करने के तरीके शामिल हैं। form_urlencode और form_urldecode

Question 9

Xperroni से प्रेरित होकर मैंने एक डिकोडर लिखा। सूचक के लिए धन्यवाद।

#include <iostream>
#include <sstream>
#include <string>

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;
}

संपादित करें: हटाए गए अनावश्यक cctype और iomainip शामिल हैं।

Question 10

Libcurl का उपयोग करने के लिए बिल की सिफारिश का पालन करना: महान सुझाव, और अपडेट किया जाना:
3 साल के बाद, curl_escape फ़ंक्शन को पदावनत कर दिया जाता है, इसलिए भविष्य के उपयोग के लिए curl_easy__cape का उपयोग करना बेहतर होता है ।

Question 11

मैं इस सवाल पर समाप्त हुआ जब एक win32 c ++ ऐप में url को डीकोड करने के लिए एक एपीआई की खोज की। चूंकि सवाल यह नहीं बताता है कि प्लेटफ़ॉर्म संभालने के लिए विंडोज़ एक बुरी चीज़ नहीं है।

InternetCanonicalizeUrl विंडोज़ प्रोग्राम के लिए एपीआई है। अधिक जानकारी यहाँ

        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 ( यहाँ ) यह भी निर्दिष्ट करता है कि url को डीकोड करना है या नहीं

Question 12

मैं यहाँ एक यूआरआई डिकोड / यूनेस्केप नहीं ढूंढ सका जो 2 और 3 बाइट सीक्वेंस को भी डिकोड करता है। अपने स्वयं के उच्च प्रदर्शन संस्करण में योगदान करते हुए, कि ऑन-द-फ्लाई c स्टिंग इनपुट को wstring में परिवर्तित करता है:

#include <string>

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;
}

Question 13

Windows API में इस कार्य के लिए, UrlEscape / UrlUnescape है , जिसे shlwapi.dll द्वारा निर्यात किया गया है।

Question 14

यह संस्करण शुद्ध C है और वैकल्पिक रूप से संसाधन पथ को सामान्य कर सकता है। C ++ के साथ इसका उपयोग करना तुच्छ है:

#include <string>
#include <iostream>

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;
}

आउटपुट:

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

और वास्तविक कार्य:

#include <stddef.h>
#include <ctype.h>

/**
 * 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 <johan@linkdata.se>
 * @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;
}

Question 15

रसदार बिट्स

#include <ctype.h> // 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];
}

नोट किया कि

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

जैसे की

// %7B = '{'

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

Question 16

आप "g_uri_escape_string ()" फ़ंक्शन glib.h प्रदान कर सकते हैं। https://developer.gnome.org/glib/stable/glib-URI-Functions.html

#include <stdio.h>
#include <stdlib.h>
#include <glib.h>
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;
}

इसे संकलित करें:

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

Question 17

एक और समाधान फेसबुक के मूर्खतापूर्ण पुस्तकालय का उपयोग करके उपलब्ध है : folly::uriEscapeऔर folly::uriUnescape।

Question 18

मुझे पता है कि सवाल एक सी ++ विधि के लिए पूछता है, लेकिन जिन लोगों को इसकी आवश्यकता हो सकती है, मैं एक स्ट्रिंग को एन्कोड करने के लिए सादे सी में एक बहुत ही कम फ़ंक्शन के साथ आया था। यह एक नया स्ट्रिंग नहीं बनाता है, बल्कि यह मौजूदा को बदल देता है, जिसका अर्थ है कि नए स्ट्रिंग को पकड़ने के लिए पर्याप्त आकार होना चाहिए। ऊपर रखना बहुत आसान है।

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

Question 19

आप केवल atlutil.h से फ़ंक्शन AtlEscapeUrl () का उपयोग कर सकते हैं, बस इसे कैसे उपयोग करना है, इसके प्रलेखन के माध्यम से जाना।

Question 20

बूस्ट के बिना एक परियोजना में यह करना था। इसलिए, अपना खुद का लेखन समाप्त कर दिया। मैं इसे केवल 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;
}