tests/libtest/lib506.c

   1 /*****************************************************************************
   2  *                                  _   _ ____  _
   3  *  Project                     ___| | | |  _ \| |
   4  *                             / __| | | | |_) | |
   5  *                            | (__| |_| |  _ <| |___
   6  *                             \___|\___/|_| \_\_____|
   7  *
   8  * $Id$
   9  */
  10
  11 #include "test.h"
  12 #include <stdlib.h>
  13 #include <ctype.h>
  14 #include <errno.h>
  15
  16 #include <curl/mprintf.h>
  17
  18 static const char *HOSTHEADER = "Host: www.host.foo.com";
  19 static const char *JAR = "log/jar506";
  20 #define THREADS 2
  21
  22 /* struct containing data of a thread */
  23 struct Tdata {
  24   CURLSH *share;
  25   char *url;
  26 };
  27
  28 struct userdata {
  29   char *text;
  30   int counter;
  31 };
  32
  33 /* lock callback */
  34 static void my_lock(CURL *handle, curl_lock_data data, curl_lock_access laccess,
  35           void *useptr )
  36 {
  37   const char *what;
  38   struct userdata *user = (struct userdata *)useptr;
  39
  40   (void)handle;
  41   (void)laccess;
  42
  43   switch ( data ) {
  44     case CURL_LOCK_DATA_SHARE:
  45       what = "share";
  46       break;
  47     case CURL_LOCK_DATA_DNS:
  48       what = "dns";
  49       break;
  50     case CURL_LOCK_DATA_COOKIE:
  51       what = "cookie";
  52       break;
  53     default:
  54       fprintf(stderr, "lock: no such data: %d\n", (int)data);
  55       return;
  56   }
  57   printf("lock:   %-6s [%s]: %d\n", what, user->text, user->counter);
  58   user->counter++;
  59 }
  60
  61 /* unlock callback */
  62 static void my_unlock(CURL *handle, curl_lock_data data, void *useptr )
  63 {
  64   const char *what;
  65   struct userdata *user = (struct userdata *)useptr;
  66   (void)handle;
  67   switch ( data ) {
  68     case CURL_LOCK_DATA_SHARE:
  69       what = "share";
  70       break;
  71     case CURL_LOCK_DATA_DNS:
  72       what = "dns";
  73       break;
  74     case CURL_LOCK_DATA_COOKIE:
  75       what = "cookie";
  76       break;
  77     default:
  78       fprintf(stderr, "unlock: no such data: %d\n", (int)data);
  79       return;
  80   }
  81   printf("unlock: %-6s [%s]: %d\n", what, user->text, user->counter);
  82   user->counter++;
  83 }
  84
  85
  86 /* build host entry */
  87 static struct curl_slist *sethost(struct curl_slist *headers)
  88 {
  89   (void)headers;
  90   return curl_slist_append(NULL, HOSTHEADER );
  91 }
  92
  93
  94 /* the dummy thread function */
  95 static void *fire(void *ptr)
  96 {
  97   CURLcode code;
  98   struct curl_slist *headers;
  99   struct Tdata *tdata = (struct Tdata*)ptr;
 100   CURL *curl;
 101   int i=0;
 102
 103   if ((curl = curl_easy_init()) == NULL) {
 104     fprintf(stderr, "curl_easy_init() failed\n");
 105     return NULL;
 106   }
 107
 108   headers = sethost(NULL);
 109   curl_easy_setopt(curl, CURLOPT_VERBOSE,    1L);
 110   curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
 111   curl_easy_setopt(curl, CURLOPT_URL,        tdata->url);
 112   printf( "CURLOPT_SHARE\n" );
 113   curl_easy_setopt(curl, CURLOPT_SHARE, tdata->share);
 114
 115   printf( "PERFORM\n" );
 116   code = curl_easy_perform(curl);
 117   if( code != CURLE_OK ) {
 118     fprintf(stderr, "perform url '%s' repeat %d failed, curlcode %d\n",
 119             tdata->url, i, (int)code);
 120   }
 121
 122   printf( "CLEANUP\n" );
 123   curl_easy_cleanup(curl);
 124   curl_slist_free_all(headers);
 125
 126   return NULL;
 127 }
 128
 129
 130 /* build request url */
 131 static char *suburl(const char *base, int i)
 132 {
 133   return curl_maprintf("%s000%c", base, 48+i);
 134 }
 135
 136
 137 /* test function */
 138 int test(char *URL)
 139 {
 140   int res;
 141   CURLSHcode scode = CURLSHE_OK;
 142   char *url;
 143   struct Tdata tdata;
 144   CURL *curl;
 145   CURLSH *share;
 146   struct curl_slist *headers;
 147   int i;
 148   struct userdata user;
 149
 150   user.text = (char *)"Pigs in space";
 151   user.counter = 0;
 152
 153   printf( "GLOBAL_INIT\n" );
 154   if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK) {
 155     fprintf(stderr, "curl_global_init() failed\n");
 156     return TEST_ERR_MAJOR_BAD;
 157   }
 158
 159   /* prepare share */
 160   printf( "SHARE_INIT\n" );
 161   if ((share = curl_share_init()) == NULL) {
 162     fprintf(stderr, "curl_share_init() failed\n");
 163     curl_global_cleanup();
 164     return TEST_ERR_MAJOR_BAD;
 165   }
 166
 167   if ( CURLSHE_OK == scode ) {
 168     printf( "CURLSHOPT_LOCKFUNC\n" );
 169     scode = curl_share_setopt( share, CURLSHOPT_LOCKFUNC, my_lock);
 170   }
 171   if ( CURLSHE_OK == scode ) {
 172     printf( "CURLSHOPT_UNLOCKFUNC\n" );
 173     scode = curl_share_setopt( share, CURLSHOPT_UNLOCKFUNC, my_unlock);
 174   }
 175   if ( CURLSHE_OK == scode ) {
 176     printf( "CURLSHOPT_USERDATA\n" );
 177     scode = curl_share_setopt( share, CURLSHOPT_USERDATA, &user);
 178   }
 179   if ( CURLSHE_OK == scode ) {
 180     printf( "CURL_LOCK_DATA_COOKIE\n" );
 181     scode = curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_COOKIE);
 182   }
 183   if ( CURLSHE_OK == scode ) {
 184     printf( "CURL_LOCK_DATA_DNS\n" );
 185     scode = curl_share_setopt( share, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
 186   }
 187
 188   if ( CURLSHE_OK != scode ) {
 189     fprintf(stderr, "curl_share_setopt() failed\n");
 190     curl_share_cleanup(share);
 191     curl_global_cleanup();
 192     return TEST_ERR_MAJOR_BAD;
 193   }
 194
 195
 196   res = 0;
 197
 198   /* start treads */
 199   for (i=1; i<=THREADS; i++ ) {
 200
 201     /* set thread data */
 202     tdata.url   = suburl( URL, i ); /* must be curl_free()d */
 203     tdata.share = share;
 204
 205     /* simulate thread, direct call of "thread" function */
 206     printf( "*** run %d\n",i );
 207     fire( &tdata );
 208
 209     curl_free( tdata.url );
 210
 211   }
 212
 213
 214   /* fetch a another one and save cookies */
 215   printf( "*** run %d\n", i );
 216   if ((curl = curl_easy_init()) == NULL) {
 217     fprintf(stderr, "curl_easy_init() failed\n");
 218     curl_share_cleanup(share);
 219     curl_global_cleanup();
 220     return TEST_ERR_MAJOR_BAD;
 221   }
 222
 223   url = suburl( URL, i );
 224   headers = sethost( NULL );
 225   curl_easy_setopt( curl, CURLOPT_HTTPHEADER, headers );
 226   curl_easy_setopt( curl, CURLOPT_URL,        url );
 227   printf( "CURLOPT_SHARE\n" );
 228   curl_easy_setopt( curl, CURLOPT_SHARE,      share );
 229   printf( "CURLOPT_COOKIEJAR\n" );
 230   curl_easy_setopt( curl, CURLOPT_COOKIEJAR,  JAR );
 231
 232   printf( "PERFORM\n" );
 233   curl_easy_perform( curl );
 234
 235   /* try to free share, expect to fail because share is in use*/
 236   printf( "try SHARE_CLEANUP...\n" );
 237   scode = curl_share_cleanup( share );
 238   if ( scode==CURLSHE_OK )
 239   {
 240     fprintf(stderr, "curl_share_cleanup succeed but error expected\n");
 241     share = NULL;
 242   } else {
 243     printf( "SHARE_CLEANUP failed, correct\n" );
 244   }
 245
 246   /* clean up last handle */
 247   printf( "CLEANUP\n" );
 248   curl_easy_cleanup( curl );
 249   curl_slist_free_all( headers );
 250
 251   curl_free(url);
 252
 253   /* free share */
 254   printf( "SHARE_CLEANUP\n" );
 255   scode = curl_share_cleanup( share );
 256   if ( scode!=CURLSHE_OK )
 257     fprintf(stderr, "curl_share_cleanup failed, code errno %d\n",
 258             (int)scode);
 259
 260   printf( "GLOBAL_CLEANUP\n" );
 261   curl_global_cleanup();
 262
 263   return res;
 264 }
 265