~mordred/libmemcached/pandora-build

« back to all changes in this revision

Viewing changes to libmemcached/sasl.c

  • Committer: Brian Aker
  • Date: 2010-04-06 19:33:06 UTC
  • Revision ID: brian@gaz-20100406193306-323622xl553w37jf
Fix issue with memcached_st structure being a different size based on
compile.

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
void memcached_set_sasl_callbacks(memcached_st *ptr,
15
15
                                  const sasl_callback_t *callbacks)
16
16
{
17
 
  ptr->sasl.callbacks= callbacks;
18
 
  ptr->sasl.is_allocated= false;
 
17
  ptr->sasl->callbacks= callbacks;
 
18
  ptr->sasl->is_allocated= false;
19
19
}
20
20
 
21
21
const sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
22
22
{
23
 
  return ptr->sasl.callbacks;
 
23
  return ptr->sasl->callbacks;
24
24
}
25
25
 
26
26
/**
116
116
 
117
117
  sasl_conn_t *conn;
118
118
  int ret= sasl_client_new("memcached", server->hostname, laddr, raddr,
119
 
                           server->root->sasl.callbacks, 0, &conn);
 
119
                           server->root->sasl->callbacks, 0, &conn);
120
120
  if (ret != SASL_OK)
121
121
  {
122
122
    return MEMCACHED_AUTH_PROBLEM;
218
218
                                                const char *password)
219
219
{
220
220
  if (ptr == NULL || username == NULL ||
221
 
      password == NULL || ptr->sasl.callbacks != NULL)
 
221
      password == NULL || ptr->sasl->callbacks != NULL)
222
222
  {
223
223
    return MEMCACHED_FAILURE;
224
224
  }
249
249
  cb[2].context= secret;
250
250
  cb[3].id= SASL_CB_LIST_END;
251
251
 
252
 
  ptr->sasl.callbacks= cb;
253
 
  ptr->sasl.is_allocated= true;
 
252
  ptr->sasl->callbacks= cb;
 
253
  ptr->sasl->is_allocated= true;
254
254
 
255
255
  return MEMCACHED_SUCCESS;
256
256
}
257
257
 
258
258
memcached_return_t memcached_destroy_sasl_auth_data(memcached_st *ptr)
259
259
{
260
 
   if (ptr == NULL || ptr->sasl.callbacks == NULL)
 
260
   if (ptr == NULL || ptr->sasl->callbacks == NULL)
261
261
   {
262
262
     return MEMCACHED_FAILURE;
263
263
   }
264
264
 
265
 
   if (ptr->sasl.is_allocated)
 
265
   if (ptr->sasl->is_allocated)
266
266
   {
267
 
     libmemcached_free(ptr, ptr->sasl.callbacks[0].context);
268
 
     libmemcached_free(ptr, ptr->sasl.callbacks[2].context);
269
 
     libmemcached_free(ptr, (void*)ptr->sasl.callbacks);
270
 
     ptr->sasl.is_allocated= false;
 
267
     libmemcached_free(ptr, ptr->sasl->callbacks[0].context);
 
268
     libmemcached_free(ptr, ptr->sasl->callbacks[2].context);
 
269
     libmemcached_free(ptr, (void*)ptr->sasl->callbacks);
 
270
     ptr->sasl->is_allocated= false;
271
271
   }
272
272
 
273
 
   ptr->sasl.callbacks= NULL;
 
273
   ptr->sasl->callbacks= NULL;
 
274
   libmemcached_free(ptr, ptr->sasl);
 
275
   ptr->sasl= NULL;
274
276
 
275
277
   return MEMCACHED_SUCCESS;
276
278
}
277
279
 
278
280
memcached_return_t memcached_clone_sasl(memcached_st *clone, const  memcached_st *source)
279
281
{
 
282
  if (source->sasl == NULL)
 
283
  {
 
284
    return MEMCACHED_SUCCESS;
 
285
  }
 
286
  else
 
287
  {
 
288
    clone->sasl= libmemcached_malloc(source, sizeof(struct memcached_sasl_st));
 
289
 
 
290
    if (clone->sasl == NULL)
 
291
    {
 
292
      return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 
293
    }
 
294
  }
 
295
 
280
296
  /* Hopefully we are using our own callback mechanisms.. */
281
 
  if (source->sasl.callbacks[0].id == SASL_CB_USER &&
282
 
      source->sasl.callbacks[0].proc == get_username &&
283
 
      source->sasl.callbacks[1].id == SASL_CB_AUTHNAME &&
284
 
      source->sasl.callbacks[1].proc == get_username &&
285
 
      source->sasl.callbacks[2].id == SASL_CB_PASS &&
286
 
      source->sasl.callbacks[2].proc == get_password &&
287
 
      source->sasl.callbacks[3].id == SASL_CB_LIST_END)
 
297
  if (source->sasl->callbacks[0].id == SASL_CB_USER &&
 
298
      source->sasl->callbacks[0].proc == get_username &&
 
299
      source->sasl->callbacks[1].id == SASL_CB_AUTHNAME &&
 
300
      source->sasl->callbacks[1].proc == get_username &&
 
301
      source->sasl->callbacks[2].id == SASL_CB_PASS &&
 
302
      source->sasl->callbacks[2].proc == get_password &&
 
303
      source->sasl->callbacks[3].id == SASL_CB_LIST_END)
288
304
  {
289
 
    sasl_secret_t *secret= source->sasl.callbacks[2].context;
 
305
    sasl_secret_t *secret= source->sasl->callbacks[2].context;
290
306
    return memcached_set_sasl_auth_data(clone,
291
 
                                        source->sasl.callbacks[0].context,
 
307
                                        source->sasl->callbacks[0].context,
292
308
                                        (const char*)secret->data);
293
309
  }
294
310
 
299
315
   */
300
316
  size_t total= 0;
301
317
 
302
 
  while (source->sasl.callbacks[total].id != SASL_CB_LIST_END) {
303
 
    switch (source->sasl.callbacks[total].id)
 
318
  while (source->sasl->callbacks[total].id != SASL_CB_LIST_END)
 
319
  {
 
320
    switch (source->sasl->callbacks[total].id)
304
321
    {
305
322
    case SASL_CB_USER:
306
323
    case SASL_CB_AUTHNAME:
314
331
    ++total;
315
332
  }
316
333
 
317
 
  sasl_callback_t *cb= libmemcached_calloc(clone, total + 1,
318
 
                                           sizeof(sasl_callback_t));
 
334
  sasl_callback_t *cb= libmemcached_calloc(clone, total + 1, sizeof(sasl_callback_t));
319
335
  if (cb == NULL)
320
336
  {
321
337
    return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
322
338
  }
323
 
  memcpy(cb, source->sasl.callbacks, (total + 1) * sizeof(sasl_callback_t));
 
339
  memcpy(cb, source->sasl->callbacks, (total + 1) * sizeof(sasl_callback_t));
324
340
 
325
341
  /* Now update the context... */
326
342
  for (size_t x= 0; x < total; ++x)
327
343
  {
328
344
    if (cb[x].id == SASL_CB_USER || cb[x].id == SASL_CB_AUTHNAME)
329
345
    {
330
 
      cb[x].context= libmemcached_malloc(clone, strlen(source->sasl.callbacks[x].context));
 
346
      cb[x].context= libmemcached_malloc(clone, strlen(source->sasl->callbacks[x].context));
 
347
 
331
348
      if (cb[x].context == NULL)
332
349
      {
333
350
        /* Failed to allocate memory, clean up previously allocated memory */
334
351
        for (size_t y= 0; y < x; ++y)
335
352
        {
336
 
          libmemcached_free(clone, clone->sasl.callbacks[y].context);
 
353
          libmemcached_free(clone, clone->sasl->callbacks[y].context);
337
354
        }
338
355
 
339
356
        libmemcached_free(clone, cb);
340
357
        return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
341
358
      }
342
 
      strcpy(cb[x].context, source->sasl.callbacks[x].context);
 
359
      strcpy(cb[x].context, source->sasl->callbacks[x].context);
343
360
    }
344
361
    else
345
362
    {
346
 
      sasl_secret_t *src = source->sasl.callbacks[x].context;
 
363
      sasl_secret_t *src = source->sasl->callbacks[x].context;
347
364
      sasl_secret_t *n = libmemcached_malloc(clone, src->len + 1 + sizeof(*n));
348
365
      if (n == NULL)
349
366
      {
350
367
        /* Failed to allocate memory, clean up previously allocated memory */
351
368
        for (size_t y= 0; y < x; ++y)
352
369
        {
353
 
          libmemcached_free(clone, clone->sasl.callbacks[y].context);
 
370
          libmemcached_free(clone, clone->sasl->callbacks[y].context);
354
371
        }
355
372
 
356
373
        libmemcached_free(clone, cb);
361
378
    }
362
379
  }
363
380
 
364
 
  clone->sasl.callbacks= cb;
365
 
  clone->sasl.is_allocated= true;
 
381
  clone->sasl->callbacks= cb;
 
382
  clone->sasl->is_allocated= true;
366
383
 
367
384
  return MEMCACHED_SUCCESS;
368
385
}