git.m6w6.name Git - m6w6/libmemcached/blob - libmemcached/memcached_server.c

   1 /*
   2   This is a partial implementation for fetching/creating memcached_server_st objects.
   3 */
   4 #include "common.h"
   5
   6 memcached_server_st *memcached_server_create(memcached_st *memc, memcached_server_st *ptr)
   7 {
   8   if (ptr == NULL)
   9   {
  10     ptr= (memcached_server_st *)malloc(sizeof(memcached_server_st));
  11
  12     if (!ptr)
  13       return NULL; /*  MEMCACHED_MEMORY_ALLOCATION_FAILURE */
  14
  15     memset(ptr, 0, sizeof(memcached_server_st));
  16     ptr->is_allocated= MEMCACHED_ALLOCATED;
  17   }
  18   else
  19   {
  20     ptr->is_allocated= MEMCACHED_USED;
  21     memset(ptr, 0, sizeof(memcached_server_st));
  22   }
  23
  24   ptr->root= memc;
  25
  26   return ptr;
  27 }
  28
  29 memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host,
  30                                                   const char *hostname, unsigned int port,
  31                                                   uint32_t weight, memcached_connection type)
  32 {
  33   host= memcached_server_create(memc, host);
  34
  35   if (host == NULL)
  36     return NULL;
  37
  38   strncpy(host->hostname, hostname, MEMCACHED_MAX_HOST_LENGTH - 1);
  39   host->root= memc ? memc : NULL;
  40   host->port= port;
  41   host->weight= weight;
  42   host->fd= -1;
  43   host->type= type;
  44   host->read_ptr= host->read_buffer;
  45   if (memc)
  46     host->next_retry= memc->retry_timeout;
  47   host->sockaddr_inited= MEMCACHED_NOT_ALLOCATED;
  48
  49   return host;
  50 }
  51
  52 void memcached_server_free(memcached_server_st *ptr)
  53 {
  54   memcached_quit_server(ptr, 0);
  55
  56   if (ptr->address_info)
  57   {
  58     freeaddrinfo(ptr->address_info);
  59     ptr->address_info= NULL;
  60   }
  61
  62   if (ptr->is_allocated == MEMCACHED_ALLOCATED)
  63   {
  64     if (ptr->root && ptr->root->call_free)
  65       ptr->root->call_free(ptr->root, ptr);
  66     else
  67       free(ptr);
  68   }
  69 }
  70
  71 /*
  72   If we do not have a valid object to clone from, we toss an error.
  73 */
  74 memcached_server_st *memcached_server_clone(memcached_server_st *clone, memcached_server_st *ptr)
  75 {
  76   memcached_server_st *new_clone;
  77
  78   /* We just do a normal create if ptr is missing */
  79   if (ptr == NULL)
  80     return NULL;
  81
  82   if (clone && clone->is_allocated == MEMCACHED_USED)
  83   {
  84     WATCHPOINT_ASSERT(0);
  85     return NULL;
  86   }
  87
  88   new_clone= memcached_server_create(ptr->root, clone);
  89
  90   if (new_clone == NULL)
  91     return NULL;
  92
  93   new_clone->root= ptr->root;
  94
  95   /* TODO We should check return type */
  96   memcached_server_create_with(new_clone->root, new_clone,
  97                                ptr->hostname, ptr->port, ptr->weight,
  98                                ptr->type);
  99
 100   return new_clone;
 101 }
 102
 103 memcached_return memcached_server_cursor(memcached_st *ptr,
 104                                          memcached_server_function *callback,
 105                                          void *context,
 106                                          unsigned int number_of_callbacks)
 107 {
 108   unsigned int y;
 109
 110   for (y= 0; y < ptr->number_of_hosts; y++)
 111   {
 112     unsigned int x;
 113
 114     for (x= 0; x < number_of_callbacks; x++)
 115     {
 116       unsigned int iferror;
 117
 118       iferror= (*callback[x])(ptr, &ptr->hosts[y], context);
 119
 120       if (iferror)
 121         continue;
 122     }
 123   }
 124
 125   return MEMCACHED_SUCCESS;
 126 }
 127
 128 memcached_server_st *memcached_server_by_key(memcached_st *ptr,  const char *key, size_t key_length, memcached_return *error)
 129 {
 130   uint32_t server_key;
 131
 132   unlikely (key_length == 0)
 133   {
 134     *error= MEMCACHED_NO_KEY_PROVIDED;
 135     return NULL;
 136   }
 137
 138   unlikely (ptr->number_of_hosts == 0)
 139   {
 140     *error= MEMCACHED_NO_SERVERS;
 141     return NULL;
 142   }
 143
 144   if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
 145   {
 146     *error= MEMCACHED_BAD_KEY_PROVIDED;
 147     return NULL;
 148   }
 149
 150   server_key= memcached_generate_hash(ptr, key, key_length);
 151
 152   return memcached_server_clone(NULL, &ptr->hosts[server_key]);
 153
 154 }