*
* Libmemcached library
*
- * Copyright (C) 2011 Data Differential, http://datadifferential.com/
+ * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
* Copyright (C) 2006-2009 Brian Aker All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
*
*/
-#include <libmemcached/common.h>
+#include "libmemcached/common.h"
#include <cassert>
#if defined(LIBMEMCACHED_WITH_SASL_SUPPORT) && LIBMEMCACHED_WITH_SASL_SUPPORT
#include <sasl/sasl.h>
#endif
+#define CAST_SASL_CB(cb) reinterpret_cast<int(*)()>(reinterpret_cast<intptr_t>(cb))
+
#include <pthread.h>
-void memcached_set_sasl_callbacks(memcached_st *ptr,
+void memcached_set_sasl_callbacks(memcached_st *shell,
const sasl_callback_t *callbacks)
{
- ptr->sasl.callbacks= const_cast<sasl_callback_t *>(callbacks);
- ptr->sasl.is_allocated= false;
+ Memcached* self= memcached2Memcached(shell);
+ if (self)
+ {
+ self->sasl.callbacks= const_cast<sasl_callback_t *>(callbacks);
+ self->sasl.is_allocated= false;
+ }
}
-sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *ptr)
+sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *shell)
{
- return ptr->sasl.callbacks;
+ Memcached* self= memcached2Memcached(shell);
+ if (self)
+ {
+ return self->sasl.callbacks;
+ }
+
+ return NULL;
}
/**
* @param raddr remote address (out)
* @return true on success false otherwise (errno contains more info)
*/
-static memcached_return_t resolve_names(memcached_server_st& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
+static memcached_return_t resolve_names(memcached_instance_st& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
{
- char host[NI_MAXHOST];
- char port[NI_MAXSERV];
+ char host[MEMCACHED_NI_MAXHOST];
+ char port[MEMCACHED_NI_MAXSERV];
struct sockaddr_storage saddr;
socklen_t salen= sizeof(saddr);
if (getsockname(server.fd, (struct sockaddr *)&saddr, &salen) < 0)
{
- return memcached_set_errno(server, MEMCACHED_ERRNO, MEMCACHED_AT);
+ return memcached_set_error(server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT);
}
if (getnameinfo((struct sockaddr *)&saddr, salen, host, sizeof(host), port, sizeof(port), NI_NUMERICHOST | NI_NUMERICSERV) < 0)
{
- return MEMCACHED_HOST_LOOKUP_FAILURE;
+ return memcached_set_error(server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT);
}
(void)snprintf(laddr, laddr_length, "%s;%s", host, port);
if (getpeername(server.fd, (struct sockaddr *)&saddr, &salen) < 0)
{
- return memcached_set_errno(server, MEMCACHED_ERRNO, MEMCACHED_AT);
+ return memcached_set_error(server, MEMCACHED_HOST_LOOKUP_FAILURE, MEMCACHED_AT);
}
if (getnameinfo((struct sockaddr *)&saddr, salen, host, sizeof(host),
} // extern "C"
-memcached_return_t memcached_sasl_authenticate_connection(memcached_server_st *server)
+memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server)
{
if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
{
* as authenticated
*/
protocol_binary_request_no_extras request= { };
- request.message.header.request.magic= PROTOCOL_BINARY_REQ;
+
+ initialize_binary_request(server, request.message.header);
+
request.message.header.request.opcode= PROTOCOL_BINARY_CMD_SASL_LIST_MECHS;
- if (memcached_io_write(server, request.bytes,
- sizeof(request.bytes), 1) != sizeof(request.bytes))
+ if (memcached_io_write(server, request.bytes, sizeof(request.bytes), true) != sizeof(request.bytes))
{
return MEMCACHED_WRITE_FAILURE;
}
+ assert_msg(server->fd != INVALID_SOCKET, "Programmer error, invalid socket");
memcached_server_response_increment(server);
return rc;
}
+ assert_msg(server->fd != INVALID_SOCKET, "Programmer error, invalid socket");
/* set ip addresses */
- char laddr[NI_MAXHOST + NI_MAXSERV];
- char raddr[NI_MAXHOST + NI_MAXSERV];
+ char laddr[MEMCACHED_NI_MAXHOST + MEMCACHED_NI_MAXSERV];
+ char raddr[MEMCACHED_NI_MAXHOST + MEMCACHED_NI_MAXSERV];
if (memcached_failed(rc= resolve_names(*server, laddr, sizeof(laddr), raddr, sizeof(raddr))))
{
sasl_conn_t *conn;
int ret;
- if ((ret= sasl_client_new("memcached", server->hostname, laddr, raddr, server->root->sasl.callbacks, 0, &conn) ) != SASL_OK)
+ if ((ret= sasl_client_new("memcached", server->_hostname, laddr, raddr, server->root->sasl.callbacks, 0, &conn) ) != SASL_OK)
{
const char *sasl_error_msg= sasl_errstring(ret, NULL, NULL);
{ data, len }
};
- if (memcached_io_writev(server, vector, 3, true) == -1)
+ assert_msg(server->fd != INVALID_SOCKET, "Programmer error, invalid socket");
+ if (memcached_io_writev(server, vector, 3, true) == false)
{
rc= MEMCACHED_WRITE_FAILURE;
break;
}
+ assert_msg(server->fd != INVALID_SOCKET, "Programmer error, invalid socket");
memcached_server_response_increment(server);
/* read the response */
+ assert_msg(server->fd != INVALID_SOCKET, "Programmer error, invalid socket");
rc= memcached_response(server, NULL, 0, NULL);
if (rc != MEMCACHED_AUTH_CONTINUE)
{
break;
}
+ assert_msg(server->fd != INVALID_SOCKET, "Programmer error, invalid socket");
ret= sasl_client_step(conn, memcached_result_value(&server->root->result),
(unsigned int)memcached_result_length(&server->root->result),
return SASL_OK;
}
-memcached_return_t memcached_set_sasl_auth_data(memcached_st *ptr,
+memcached_return_t memcached_set_sasl_auth_data(memcached_st *shell,
const char *username,
const char *password)
{
+ Memcached* ptr= memcached2Memcached(shell);
if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
{
return MEMCACHED_NOT_SUPPORTED;
secret->data[password_length]= 0;
callbacks[0].id= SASL_CB_USER;
- callbacks[0].proc= (int (*)())get_username;
+ callbacks[0].proc= CAST_SASL_CB(get_username);
callbacks[0].context= strncpy(name, username, username_length +1);
callbacks[1].id= SASL_CB_AUTHNAME;
- callbacks[1].proc= (int (*)())get_username;
+ callbacks[1].proc= CAST_SASL_CB(get_username);
callbacks[1].context= name;
callbacks[2].id= SASL_CB_PASS;
- callbacks[2].proc= (int (*)())get_password;
+ callbacks[2].proc= CAST_SASL_CB(get_password);
callbacks[2].context= secret;
callbacks[3].id= SASL_CB_LIST_END;
return MEMCACHED_SUCCESS;
}
-memcached_return_t memcached_destroy_sasl_auth_data(memcached_st *ptr)
+memcached_return_t memcached_destroy_sasl_auth_data(memcached_st *shell)
{
if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0)
{
return MEMCACHED_NOT_SUPPORTED;
}
+ Memcached* ptr= memcached2Memcached(shell);
if (ptr == NULL)
{
return MEMCACHED_INVALID_ARGUMENTS;
/* Hopefully we are using our own callback mechanisms.. */
if (source->sasl.callbacks[0].id == SASL_CB_USER &&
- source->sasl.callbacks[0].proc == (int (*)())get_username &&
+ source->sasl.callbacks[0].proc == CAST_SASL_CB(get_username) &&
source->sasl.callbacks[1].id == SASL_CB_AUTHNAME &&
- source->sasl.callbacks[1].proc == (int (*)())get_username &&
+ source->sasl.callbacks[1].proc == CAST_SASL_CB(get_username) &&
source->sasl.callbacks[2].id == SASL_CB_PASS &&
- source->sasl.callbacks[2].proc == (int (*)())get_password &&
+ source->sasl.callbacks[2].proc == CAST_SASL_CB(get_password) &&
source->sasl.callbacks[3].id == SASL_CB_LIST_END)
{
sasl_secret_t *secret= (sasl_secret_t *)source->sasl.callbacks[2].context;
* into the list, but if we don't know the ID we don't know how to handle
* the context...
*/
- size_t total= 0;
+ ptrdiff_t total= 0;
while (source->sasl.callbacks[total].id != SASL_CB_LIST_END)
{
memcpy(callbacks, source->sasl.callbacks, (total + 1) * sizeof(sasl_callback_t));
/* Now update the context... */
- for (size_t x= 0; x < total; ++x)
+ for (ptrdiff_t x= 0; x < total; ++x)
{
if (callbacks[x].id == SASL_CB_USER || callbacks[x].id == SASL_CB_AUTHNAME)
{
if (callbacks[x].context == NULL)
{
/* Failed to allocate memory, clean up previously allocated memory */
- for (size_t y= 0; y < x; ++y)
+ for (ptrdiff_t y= 0; y < x; ++y)
{
libmemcached_free(clone, clone->sasl.callbacks[y].context);
}
if (n == NULL)
{
/* Failed to allocate memory, clean up previously allocated memory */
- for (size_t y= 0; y < x; ++y)
+ for (ptrdiff_t y= 0; y < x; ++y)
{
libmemcached_free(clone, clone->sasl.callbacks[y].context);
}