Un modo semplice per analizzare un url in C ++ cross platform?

Ho bisogno di analizzare un URL per ottenere il protocollo, l’host, il percorso e la query in un’applicazione che sto scrivendo in C ++. L’applicazione è destinata a essere multipiattaforma. Sono sorpreso di non riuscire a trovare nulla che funzioni nelle librerie boost o POCO . È ovvio che non sto guardando? Qualche suggerimento sulle librerie open source appropriate? O è qualcosa che devo fare solo io? Non è molto complicato, ma sembra un compito così comune che mi sorprende che non ci sia una soluzione comune.

Esiste una libreria proposta per l’inclusione Boost e consente di analizzare facilmente gli URI HTTP. Usa Boost.Spirit ed è anche rilasciato sotto la licenza del software Boost. La libreria è cpp-netlib che puoi trovare nella documentazione all’indirizzo http://cpp-netlib.github.com/ – puoi scaricare l’ultima versione da http://github.com/cpp-netlib/cpp-netlib / download .

Il tipo rilevante che vorrete usare è boost::network::http::uri ed è documentato qui .

Scusa terribilmente, non potevo evitarlo. :S

url.hh

 #ifndef URL_HH_ #define URL_HH_ #include  struct url { url(const std::string& url_s); // omitted copy, ==, accessors, ... private: void parse(const std::string& url_s); private: std::string protocol_, host_, path_, query_; }; #endif /* URL_HH_ */ 

url.cc

 #include "url.hh" #include  #include  #include  #include  using namespace std; // ctors, copy, equality, ... void url::parse(const string& url_s) { const string prot_end("://"); string::const_iterator prot_i = search(url_s.begin(), url_s.end(), prot_end.begin(), prot_end.end()); protocol_.reserve(distance(url_s.begin(), prot_i)); transform(url_s.begin(), prot_i, back_inserter(protocol_), ptr_fun(tolower)); // protocol is icase if( prot_i == url_s.end() ) return; advance(prot_i, prot_end.length()); string::const_iterator path_i = find(prot_i, url_s.end(), '/'); host_.reserve(distance(prot_i, path_i)); transform(prot_i, path_i, back_inserter(host_), ptr_fun(tolower)); // host is icase string::const_iterator query_i = find(path_i, url_s.end(), '?'); path_.assign(path_i, query_i); if( query_i != url_s.end() ) ++query_i; query_.assign(query_i, url_s.end()); } 

main.cc

 // ... url u("HTTP://stackoverflow.com/questions/2616011/parse-a.py?url=1"); cout < < u.protocol() << '\t' << u.host() << ... 

La versione precedente di Wstring, ha aggiunto altri campi di cui avevo bisogno. Potrebbe sicuramente essere raffinato, ma abbastanza buono per i miei scopi.

 #include  #include  // find struct Uri { public: std::wstring QueryString, Path, Protocol, Host, Port; static Uri Parse(const std::wstring &uri) { Uri result; typedef std::wstring::const_iterator iterator_t; if (uri.length() == 0) return result; iterator_t uriEnd = uri.end(); // get query start iterator_t queryStart = std::find(uri.begin(), uriEnd, L'?'); // protocol iterator_t protocolStart = uri.begin(); iterator_t protocolEnd = std::find(protocolStart, uriEnd, L':'); //"://"); if (protocolEnd != uriEnd) { std::wstring prot = &*(protocolEnd); if ((prot.length() > 3) && (prot.substr(0, 3) == L"://")) { result.Protocol = std::wstring(protocolStart, protocolEnd); protocolEnd += 3; // :// } else protocolEnd = uri.begin(); // no protocol } else protocolEnd = uri.begin(); // no protocol // host iterator_t hostStart = protocolEnd; iterator_t pathStart = std::find(hostStart, uriEnd, L'/'); // get pathStart iterator_t hostEnd = std::find(protocolEnd, (pathStart != uriEnd) ? pathStart : queryStart, L':'); // check for port result.Host = std::wstring(hostStart, hostEnd); // port if ((hostEnd != uriEnd) && ((&*(hostEnd))[0] == L':')) // we have a port { hostEnd++; iterator_t portEnd = (pathStart != uriEnd) ? pathStart : queryStart; result.Port = std::wstring(hostEnd, portEnd); } // path if (pathStart != uriEnd) result.Path = std::wstring(pathStart, queryStart); // query if (queryStart != uriEnd) result.QueryString = std::wstring(queryStart, uri.end()); return result; } // Parse }; // uri 

Prove / Uso

 Uri u0 = Uri::Parse(L"http://localhost:80/foo.html?&q=1:2:3"); Uri u1 = Uri::Parse(L"https://localhost:80/foo.html?&q=1"); Uri u2 = Uri::Parse(L"localhost/foo"); Uri u3 = Uri::Parse(L"https://localhost/foo"); Uri u4 = Uri::Parse(L"localhost:8080"); Uri u5 = Uri::Parse(L"localhost?&foo=1"); Uri u6 = Uri::Parse(L"localhost?&foo=1:2:3"); u0.QueryString, u0.Path, u0.Protocol, u0.Host, u0.Port.... 

Per completezza, ce n’è uno scritto in C che potresti usare (con un piccolo involucro, senza dubbio): http://uriparser.sourceforge.net/

[Conforms a RFC e supporta Unicode]


Ecco un wrapper molto semplice che ho utilizzato per semplicemente afferrare i risultati di un analisi.

 #include  #include  namespace uriparser { class Uri //: boost::noncopyable { public: Uri(std::string uri) : uri_(uri) { UriParserStateA state_; state_.uri = &uriParse_; isValid_ = uriParseUriA(&state_, uri_.c_str()) == URI_SUCCESS; } ~Uri() { uriFreeUriMembersA(&uriParse_); } bool isValid() const { return isValid_; } std::string scheme() const { return fromRange(uriParse_.scheme); } std::string host() const { return fromRange(uriParse_.hostText); } std::string port() const { return fromRange(uriParse_.portText); } std::string path() const { return fromList(uriParse_.pathHead, "/"); } std::string query() const { return fromRange(uriParse_.query); } std::string fragment() const { return fromRange(uriParse_.fragment); } private: std::string uri_; UriUriA uriParse_; bool isValid_; std::string fromRange(const UriTextRangeA & rng) const { return std::string(rng.first, rng.afterLast); } std::string fromList(UriPathSegmentA * xs, const std::string & delim) const { UriPathSegmentStructA * head(xs); std::string accum; while (head) { accum += delim + fromRange(head->text); head = head->next; } return accum; } }; } 

La class URI di POCO può analizzare gli URL per te. L’esempio seguente è una versione abbreviata di quella nelle diapositive URI e UUID POCO :

 #include "Poco/URI.h" #include  int main(int argc, char** argv) { Poco::URI uri1("http://www.appinf.com:88/sample?example-query#frag"); std::string scheme(uri1.getScheme()); // "http" std::string auth(uri1.getAuthority()); // "www.appinf.com:88" std::string host(uri1.getHost()); // "www.appinf.com" unsigned short port = uri1.getPort(); // 88 std::string path(uri1.getPath()); // "/sample" std::string query(uri1.getQuery()); // "example-query" std::string frag(uri1.getFragment()); // "frag" std::string pathEtc(uri1.getPathEtc()); // "/sample?example-query#frag" return 0; } 

La libreria Poco ora ha una class per sezionare gli URI e restituire l’host, i segmenti del percorso e la stringa di query, ecc.

http://www.appinf.com/docs/poco/Poco.URI.html

La libreria Folly di Facebook può fare il lavoro per te facilmente. Usa semplicemente la class Uri :

 #include  int main() { folly::Uri folly("https://code.facebook.com/posts/177011135812493/"); folly.scheme(); // https folly.host(); // code.facebook.com folly.path(); // posts/177011135812493/ } 
 //sudo apt-get install libboost-all-dev; #install boost //g++ urlregex.cpp -lboost_regex; #compile #include  #include  #include  using namespace std; int main(int argc, char* argv[]) { string url="https://www.google.com:443/webhp?gws_rd=ssl#q=cpp"; boost::regex ex("(http|https)://([^/ :]+):?([^/ ]*)(/?[^ #?]*)\\x3f?([^ #]*)#?([^ ]*)"); boost::cmatch what; if(regex_match(url.c_str(), what, ex)) { cout < < "protocol: " << string(what[1].first, what[1].second) << endl; cout << "domain: " << string(what[2].first, what[2].second) << endl; cout << "port: " << string(what[3].first, what[3].second) << endl; cout << "path: " << string(what[4].first, what[4].second) << endl; cout << "query: " << string(what[5].first, what[5].second) << endl; cout << "fragment: " << string(what[6].first, what[6].second) << endl; } return 0; } 

Anche di interesse potrebbe essere http://code.google.com/p/uri-grammar/ che come il netlib di Dean Michael usa boost spirit per analizzare un URI. È venuto attraverso l’ esempio di parser di espressioni semplici usando Boost :: Spirit?

QT ha QURL per questo. GNOME ha SoupURI in libsoup , che probabilmente troverai un po ‘più leggero.

C’è la lib di google-url appena rilasciata:

http://code.google.com/p/google-url/

La libreria fornisce un’API di analisi url di basso livello e un’astrazione di livello superiore denominata GURL. Ecco un esempio usando questo:

 #include  wchar_t url[] = L"http://www.facebook.com"; GURL parsedUrl (url); assert(parsedUrl.DomainIs("facebook.com")); 

Due piccole lamentele che ho con esso: (1) vuole usare ICU di default per trattare le diverse stringhe di stringhe e (2) fa alcune supposizioni sulla registrazione (ma penso che possano essere disabilitate). In altre parole, la libreria non è completamente autonoma come esiste, ma penso che sia ancora una buona base per iniziare, specialmente se si sta già utilizzando l’ICU.

Questa libreria è molto piccola e leggera: https://github.com/corporateshark/LUrlParser

Tuttavia, sta analizzando solo, nessuna normalizzazione / convalida dell’URL.

Stavo cercando anche una semplice libreria URI standalone per C ++. Non potendo trovarne uno ho preso la class URI da Poco, consigliato in questo argomento, e reso indipendente apportando poche modifiche ai file sorgente originali. Realizzato con soli 2 file sorgente e non richiede alcuna libreria exgernal, utilizza solo poche intestazioni da STL. Ho fatto alcuni test con i compilatori GCC e MS e l’ho messo qui sul mio sito web: http://ikk.byethost9.com/index.php?MainMenu=hef_uri_syntax Ha ribattezzato namespace Poco -> hef e rinominato URI di class principale – > HfURISyntax . È incoraggiato a rinominarli quando li usi nei tuoi progetti. (Copyright originale incluso. C’è un documento di testo che contiene il riassunto delle modifiche.)

Potresti provare la libreria open-source chiamata C ++ REST SDK (creato da Microsoft, distribuito sotto Apache License 2.0). Può essere costruito per diverse piattaforms tra cui Windows, Linux, OSX, iOS, Android). Esiste una class chiamata web::uri cui inserisci una stringa e puoi recuperare singoli componenti URL. Ecco un esempio di codice (testato su Windows):

 #include  #include  #include  web::uri sample_uri( L"http://dummyuser@localhost:7777/dummypath?dummyquery#dummyfragment" ); std::wcout < < L"scheme: " << sample_uri.scheme() << std::endl; std::wcout << L"user: " << sample_uri.user_info() << std::endl; std::wcout << L"host: " << sample_uri.host() << std::endl; std::wcout << L"port: " << sample_uri.port() << std::endl; std::wcout << L"path: " << sample_uri.path() << std::endl; std::wcout << L"query: " << sample_uri.query() << std::endl; std::wcout << L"fragment: " << sample_uri.fragment() << std::endl; 

L'output sarà:

 scheme: http user: dummyuser host: localhost port: 7777 path: /dummypath query: dummyquery fragment: dummyfragment 

Esistono anche altri metodi facili da usare, ad esempio per accedere a coppie di attributi / valori individuali dalla query, dividere il percorso in componenti, ecc.

C’è ancora un’altra libreria https://snapwebsites.org/project/libtld che gestisce tutti i possibili domini di primo livello e shema URI