* @param raddr remote address (out)
* @return true on success false otherwise (errno contains more info)
*/
-static bool resolve_names(int fd, char *laddr, char *raddr)
+static bool resolve_names(int fd, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length)
{
char host[NI_MAXHOST];
char port[NI_MAXSERV];
return false;
}
- (void)sprintf(laddr, "%s;%s", host, port);
+ (void)snprintf(laddr, laddr_length, "%s;%s", host, port);
salen= sizeof(saddr);
if ((getpeername(fd, (struct sockaddr *)&saddr, &salen) < 0) ||
return false;
}
- (void)sprintf(raddr, "%s;%s", host, port);
+ (void)snprintf(raddr, raddr_length, "%s;%s", host, port);
return true;
}
char laddr[NI_MAXHOST + NI_MAXSERV];
char raddr[NI_MAXHOST + NI_MAXSERV];
- unlikely (!resolve_names(server->fd, laddr, raddr))
+ unlikely (!resolve_names(server->fd, laddr, sizeof(laddr), raddr, sizeof(raddr)))
{
server->cached_errno= errno;
return MEMCACHED_ERRNO;
do {
/* send the packet */
- if (memcached_io_write(server, request.bytes,
- sizeof(request.bytes), 0) != sizeof(request.bytes) ||
- memcached_io_write(server, chosenmech, keylen, 0) != keylen ||
- memcached_io_write(server, data, len, 1) != (ssize_t)len)
+
+ struct libmemcached_io_vector_st vector[]=
+ {
+ { .length= sizeof(request.bytes), .buffer= request.bytes },
+ { .length= keylen, .buffer= chosenmech },
+ { .length= len, .buffer= data }
+ };
+
+ if (memcached_io_writev(server, vector, 3, true) == -1)
{
rc= MEMCACHED_WRITE_FAILURE;
goto end;
sasl_callback_t *cb= libmemcached_calloc(ptr, 4, sizeof(sasl_callback_t));
char *name= libmemcached_malloc(ptr, strlen(username) + 1);
- sasl_secret_t *secret= libmemcached_malloc(ptr, strlen(password) + 1 + sizeof(*secret))
-;
+ size_t password_length= strlen(password);
+ sasl_secret_t *secret= libmemcached_malloc(ptr, password_length +1 + sizeof(*secret));
if (cb == NULL || name == NULL || secret == NULL)
{
libmemcached_free(ptr, cb);
}
secret->len= strlen(password);
- strcpy((void*)secret->data, password);
+ memcpy(secret->data, password, password_length);
+ secret->data[password_length]= 0;
cb[0].id= SASL_CB_USER;
cb[0].proc= get_username;
- cb[0].context= strcpy(name, username);
+ cb[0].context= strncpy(name, username, sizeof(cb[0].context));
cb[1].id= SASL_CB_AUTHNAME;
cb[1].proc= get_username;
cb[1].context= name;
memcached_return_t memcached_clone_sasl(memcached_st *clone, const memcached_st *source)
{
+
+ if (source->sasl.callbacks == NULL)
+ {
+ return MEMCACHED_SUCCESS;
+ }
+
/* Hopefully we are using our own callback mechanisms.. */
if (source->sasl.callbacks[0].id == SASL_CB_USER &&
source->sasl.callbacks[0].proc == get_username &&
*/
size_t total= 0;
- while (source->sasl.callbacks[total].id != SASL_CB_LIST_END) {
+ while (source->sasl.callbacks[total].id != SASL_CB_LIST_END)
+ {
switch (source->sasl.callbacks[total].id)
{
case SASL_CB_USER:
++total;
}
- sasl_callback_t *cb= libmemcached_calloc(clone, total + 1,
- sizeof(sasl_callback_t));
+ sasl_callback_t *cb= libmemcached_calloc(clone, total + 1, sizeof(sasl_callback_t));
if (cb == NULL)
{
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
if (cb[x].id == SASL_CB_USER || cb[x].id == SASL_CB_AUTHNAME)
{
cb[x].context= libmemcached_malloc(clone, strlen(source->sasl.callbacks[x].context));
+
if (cb[x].context == NULL)
{
/* Failed to allocate memory, clean up previously allocated memory */
libmemcached_free(clone, cb);
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
}
- strcpy(cb[x].context, source->sasl.callbacks[x].context);
+ strncpy(cb[x].context, source->sasl.callbacks[x].context, sizeof(cb[x].context));
}
else
{