comment réutiliser correctement une poignée de boucle

Je veux réutiliser correctement une boucle de la poignée, de sorte qu'il ne me donne pas d'erreurs et de fonctionner normalement.

Supposons que j'ai ce bout de code:

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

Serait-ce une bonne ou d'une façon correcte de la réutilisation d'une poignée curl? Ou dois-je utiliser curl_easy_reset() sur la poignée?

J'apprécierais aussi si quelqu'un a suggéré que vous devriez éviter de le faire en boucle. Peut-être que quelqu'un pourrait me donner un lien vers une source d'information?

source d'informationauteur user1494517

c curl handle libcurl

Lorsque vous utilisez l'environnement de libcurl sur la simplicité de son interface, vous devez d'abord appeler :

curl_easy_init()qui initialisation de la poignée facile,
curl_global_init()la plupart des cas, l'option d'indicateur doit être CURL_GLOBAL_ALL

Chacune de ces deux fonctions est appelée une seule fois au début et à la nécessité, au contraire, nettoyer :

curl_easy_cleanup() lorsque vous avez fini de poignées que vous avez déclarer,
curl_global_cleanup() lorsque vous avez terminé avec libcurl,

Pour de meilleurs résultats, vérifiez les erreurs autant que vous le pouvez. Libcurl fournit curl_easy_strerror() de la fonction pour cela. Elle renvoie une chaîne de caractères décrivant le CURLcode erreur. En outre, certaines fonctions renvoient la valeur
CURL_OK ou un entier si tout est OK.

Par exemple, voici la bonne façon d'utiliser CURLOPT_URL option :

#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 vous souhaitez réutiliser cette poignée pour un tout autre but, vous feriez mieux d'utiliser différents CURL
facile poignées.
Encore votre code devrait fonctionner très bien, mais je voudrais utiliser différentes poignées car il est évidemment séparer les deux opérations.

Cependant, parfois, vous aurez besoin de travailler avec la même poignée et si vous ne voulez pas le faire réinitialiser automatiquement, utilisez la fonction appropriée :

void curl_easy_reset(CURL *handle);

Noter qu'il ne change pas de connexions en temps réel, l'ID de Session cache, le cache DNS, les biscuits et les actions de la poignée.

Je n'ai pas essayé, mais avec votre code, il devrait nous donner quelque chose comme ça :

#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 vous avez un problème avec Sleepessayez de le remplacer par sleep ou _sleep ou remplacer 5000 par 5.

Si je comprends correctement à la question que vous aimeriez savoir si vous pouvez faire un appel à curl_easy_perform() et ensuite seulement modifier l'url par le biais de curl_easy_setoption() et puis faire un deuxième appel? Cela devrait fonctionner sans erreurs puisque la fonction ne change pas toutes les options définies précédemment pour la poignée. C'est un court exemple:

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

Ou dois-je utiliser curl_easy_reset() sur la poignée?

La réponse est pas depuis curl_easy_perform() pas de réinitialiser toutes les options de votre code doit être fine et vous pouvez vous en tenir uniquement la modification de l'url comme curl_easy_setoption(curl, CURLOPT_URL, <newurl>);.

3

Ou dois-je utiliser curl_easy_reset() sur la poignée?

Vous réinitialisez il XOR propres (avant affectation de la valeur de retour de curl_easy_init() nouveau) - faire les deux n'est pas bon. Pour plus d'info, voir la documentation.

Vous devez vous connecter pour publier un commentaire.