tiras - como pelar un mango maduro

cómo reutilizar correctamente un mango de rizo

Question

Quiero reutilizar correctamente un identificador de rizo, para que no me dé errores y funcione normalmente.

Supongamos que tengo este pedazo de código:

 CURL *curl;
curl_global_init(CURL_GLOBAL_ALL);
curl = curl_easy_init();
curl_easy_setopt(curl, CURLOPT_USERAGENT, "Mozilla/5.0...");
curl_easy_setopt(curl, CURLOPT_URL, "http://www.google.com");
curl_easy_perform(curl);
curl_easy_setopt(curl, CURLOPT_URL, "http://www.bbc.com");
curl_easy_perform(curl);
curl_easy_cleanup(curl);
curl_global_cleanup();

¿Sería esta una manera buena o correcta de reutilizar un mango de rizo? ¿O necesito usar curl_easy_reset() en ese identificador?

También agradecería que alguien sugiriera lo que debe evitar hacer en rizo. ¿Tal vez alguien podría darme un enlace a una fuente de información ya existente?

Answer 1

¿O necesito usar curl_easy_reset () en ese identificador?

Puede restablecerlo XOR limpiarlo (antes de asignar el valor de retorno de curl_easy_init() nuevo): hacer ambas cosas no es bueno. Para más información, consulte la documentación .

Answer 2

Cuando usa el entorno libcurl en la interfaz fácil, primero tiene que llamar:

• curl_easy_init() , que inicia el manejo fácil,
• curl_global_init() , la mayoría de los casos, la opción del indicador debe ser CURL_GLOBAL_ALL

Cada una de esas dos funciones se llama solo una vez al principio y necesita su limpieza opuesta:

• curl_easy_cleanup() cuando hayas terminado los manejadores que has declarado,
• curl_global_cleanup() cuando haya terminado con libcurl,

Para mejores resultados revisa los errores tanto como puedas. Libcurl proporciona la función curl_easy_strerror() para eso. Devuelve una cadena que describe el error CURLcode. Además, algunas funciones devuelven el valor CURL_OK o un entero específico si todo está bien.

Por ejemplo, aquí está la forma correcta de usar la opción CURLOPT_URL:

#include <curl.h>
int main(void)
{
/* declaration of an object CURL */
CURL *handle;
/* result of the whole process */
CURLcode result;
/* the first functions */
/* set up the program environment that libcurl needs */
curl_global_init(CURL_GLOBAL_ALL);
/* curl_easy_init() returns a CURL easy handle that you''re gonna reuse in other easy functions*/
handle = curl_easy_init();
/* if everything''s all right with the easy handle... */
if(handle)
{
/* ...you can list the easy functions */
/* here we just gonna try to get the source code of http://example.com */
curl_easy_setopt(handle, CURLOPT_URL, "http://example.com");
/* but in that case we also tell libcurl to follow redirection */
curl_easy_setopt(handle, CURLOPT_FOLLOWLOCATION, 1L);
/* perform, then store the expected code in ''result''*/
result = curl_easy_perform(handle);
/* Check for errors */
if(result != CURLE_OK)
{
/* if errors have occured, tell us wath''s wrong with ''result''*/
fprintf(stderr, "curl_easy_perform() failed: %s/n", curl_easy_strerror(result));
return 1;
}
}
/* if something''s gone wrong with curl at the beginning, we''ll appriciate that piece of code */
else
{
fprintf(stderr, "Curl init failed!/n");
return 1;
}
/* cleanup since you''ve used curl_easy_init */
curl_easy_cleanup(handle);
/* this function releases resources acquired by curl_global_init() */
curl_global_cleanup();
/* make the programme stopping for avoiding the console closing befor you can see anything */
system("PAUSE");
return 0;
}

Si desea reutilizar ese asa para un propósito totalmente diferente, es mejor que use asas fáciles CURL diferentes. Aún así, su código debería funcionar bien pero usaría diferentes manejadores porque obviamente son dos operaciones separadas.

Sin embargo, a veces tendrá que trabajar con el mismo identificador y, si no desea restablecerlo automáticamente, use la función apropiada:

void curl_easy_reset(CURL *handle); 

Tenga en cuenta que no cambia las conexiones en vivo, el caché de ID de sesión, el caché de DNS, las cookies y los recursos compartidos desde el identificador.

No lo he probado, pero con su código debería darnos algo así:

#include <curl.h>
int main(void)
{
CURL *handle;
CURLcode result;
int error = 0;
int error2 = 0;
curl_global_init(CURL_GLOBAL_ALL);
handle = curl_easy_init();
if(handle)
{
curl_easy_setopt(handle, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2) Gecko/20100115 Firefox/3.6");
curl_easy_setopt(handle, CURLOPT_URL, "http://www.google.com");
result = curl_easy_perform(handle);
if(result != CURLE_OK)
{
fprintf(stderr, "curl_easy_perform() failed: %s/n", curl_easy_strerror(result));
error++;
}
Sleep(5000); // make a pause if you working on console application
curl_easy_reset(handle);
curl_easy_setopt(handle, CURLOPT_USERAGENT, "Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2) Gecko/20100115 Firefox/3.6"); // have to write it again
curl_easy_setopt(handle, CURLOPT_URL, "http://www.bbc.com");
result = curl_easy_perform(handle);
if(result != CURLE_OK)
{
fprintf(stderr, "curl_easy_perform() failed: %s/n", curl_easy_strerror(result));
error2++;
}
if(error == 1 || error2 == 1)
{
return 1;
}
}
else
{
fprintf(stderr, "Curl init failed!/n");
return 1;
}
curl_easy_cleanup(handle);
curl_global_cleanup();
system("PAUSE");
return 0;
}

Si tiene algún problema con el modo de sleep , intente reemplazarlo con el modo de sleep o _sleep o reemplace 5000 por 5.

Answer 3

Si entiendo la pregunta correctamente, le gustaría saber si puede hacer una llamada a curl_easy_perform() y luego solo cambiar la url a través de curl_easy_setoption() y luego hacer una segunda llamada. Esto debería funcionar sin ningún error, ya que la función no cambia las opciones configuradas previamente para el identificador. Este es un breve ejemplo de trabajo:

size_t writeCallback(char* contents, size_t size, size_t nmemb, std::string* buffer) {
size_t realsize = size * nmemb;
if(buffer == NULL) {
return 0;
}
buffer->append(contents, realsize);
return realsize;
}
int main(int argc, char** argv) {
std::string buffer;
// initialize global
curl_global_init(CURL_GLOBAL_ALL);
// start a libcurl easy session
CURL* ch = curl_easy_init();
// this options will only be set once
curl_easy_setopt(ch, CURLOPT_VERBOSE, 0);
curl_easy_setopt(ch, CURLOPT_FOLLOWLOCATION, 1);
curl_easy_setopt(ch, CURLOPT_USERAGENT, "Crawler");
curl_easy_setopt(ch, CURLOPT_WRITEFUNCTION, &writeCallback);
curl_easy_setopt(ch, CURLOPT_WRITEDATA, &buffer);
std::vector<const char*> queue;
queue.push_back("http://www.google.com");
queue.push_back("http://www..com");
const char* url;
CURLcode code;
do {
// grab an url from the queue
url = queue.back();
queue.pop_back();
// only change this option for the handle
// the rest will stay intact
curl_easy_setopt(ch, CURLOPT_URL, url);
// perform transfer
code = curl_easy_perform(ch);
// check if everything went fine
if(code != CURLE_OK) {
}
// clear the buffer
buffer.clear();
} while(queue.size() > 0);
// cleanup
curl_easy_cleanup(ch);
curl_global_cleanup();
return 0;
}

¿O necesito usar curl_easy_reset () en ese identificador?

La respuesta es no, ya que curl_easy_perform() no restablecerá ninguna de las opciones que su código debería tener y solo puede cambiar la URL como curl_easy_setoption(curl, CURLOPT_URL, <newurl>); .