git.m6w6.name Git - awesomized/libmemcached/blob - lib/memcached_hosts.c

   1 #include <memcached.h>
   2 #include "common.h"
   3
   4 /* Protoypes (static) */
   5 static memcached_return server_add(memcached_st *ptr, char *hostname,
   6                                    unsigned int port,
   7                                    memcached_connection type);
   8
   9 static void host_reset(memcached_server_st *host, char *new_hostname, unsigned int port,
  10                        memcached_connection type)
  11 {
  12   memset(host,  0, sizeof(memcached_server_st));
  13   host->hostname= new_hostname;
  14   host->port= port;
  15   host->fd= -1;
  16   host->type= type;
  17   host->read_ptr= host->read_buffer;
  18   host->write_ptr= host->write_buffer;
  19 }
  20
  21 memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
  22 {
  23   unsigned int x;
  24   unsigned int count;
  25   memcached_server_st *new_host_list;
  26
  27   if (!list)
  28     return MEMCACHED_SUCCESS;
  29
  30   for (count= 0; list[count].hostname; count++);
  31
  32   new_host_list=
  33     (memcached_server_st *)realloc(ptr->hosts,
  34                                    sizeof(memcached_server_st) * (count + ptr->number_of_hosts + 1));
  35
  36   if (!new_host_list)
  37     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
  38
  39   ptr->hosts= new_host_list;
  40
  41   for (x= 0; list[x].hostname; x++)
  42   {
  43     ptr->hosts[ptr->number_of_hosts].hostname= strdup(list[x].hostname);
  44     ptr->hosts[ptr->number_of_hosts].port= list[x].port;
  45     ptr->hosts[ptr->number_of_hosts].fd= list[x].fd;
  46     ptr->hosts[ptr->number_of_hosts].stack_responses= list[x].stack_responses;
  47     ptr->hosts[ptr->number_of_hosts].cursor_active= list[x].cursor_active;
  48     ptr->hosts[ptr->number_of_hosts].type= list[x].type;
  49     ptr->number_of_hosts++;
  50   }
  51   host_reset(&ptr->hosts[ptr->number_of_hosts], NULL, 0,
  52              MEMCACHED_CONNECTION_UNKNOWN);
  53
  54   return MEMCACHED_SUCCESS;
  55 }
  56
  57 memcached_return memcached_server_add_unix_socket(memcached_st *ptr, char *filename)
  58 {
  59   if (!filename)
  60     return MEMCACHED_FAILURE;
  61
  62   return server_add(ptr, filename, 0, MEMCACHED_CONNECTION_UNIX_SOCKET);
  63 }
  64
  65 memcached_return memcached_server_add_udp(memcached_st *ptr,
  66                                           char *hostname,
  67                                           unsigned int port)
  68 {
  69   if (!port)
  70     port= MEMCACHED_DEFAULT_PORT;
  71
  72   if (!hostname)
  73     hostname= "localhost";
  74
  75   return server_add(ptr, hostname, port, MEMCACHED_CONNECTION_UDP);
  76 }
  77
  78 memcached_return memcached_server_add(memcached_st *ptr,
  79                                       char *hostname,
  80                                       unsigned int port)
  81 {
  82   if (!port)
  83     port= MEMCACHED_DEFAULT_PORT;
  84
  85   if (!hostname)
  86     hostname= "localhost";
  87
  88   return server_add(ptr, hostname, port, MEMCACHED_CONNECTION_TCP);
  89 }
  90
  91 static memcached_return server_add(memcached_st *ptr, char *hostname,
  92                                    unsigned int port,
  93                                    memcached_connection type)
  94 {
  95   memcached_server_st *new_host_list;
  96   char *new_hostname;
  97   LIBMEMCACHED_MEMCACHED_SERVER_ADD_START();
  98
  99
 100   if (ptr->number_of_hosts)
 101   {
 102     new_host_list= (memcached_server_st *)realloc(ptr->hosts,
 103                                                   sizeof(memcached_server_st) * (ptr->number_of_hosts+1));
 104     if (!new_host_list)
 105       return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 106     host_reset(&new_host_list[ptr->number_of_hosts], NULL, 0,
 107                MEMCACHED_CONNECTION_UNKNOWN);
 108   }
 109   else
 110   {
 111     new_host_list=
 112       (memcached_server_st *)malloc(sizeof(memcached_server_st) * 2);
 113     if (!new_host_list)
 114       return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 115     host_reset(&new_host_list[0], NULL, 0, MEMCACHED_CONNECTION_UNKNOWN);
 116     host_reset(&new_host_list[1], NULL, 0, MEMCACHED_CONNECTION_UNKNOWN);
 117   }
 118
 119   ptr->hosts= new_host_list;
 120
 121   new_hostname=
 122     (char *)malloc(sizeof(char) * (strlen(hostname)+1));
 123
 124   if (!new_hostname)
 125     return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 126
 127   memcpy(new_hostname, hostname, strlen(hostname));
 128   host_reset(&ptr->hosts[ptr->number_of_hosts], new_hostname, port, type);
 129   ptr->number_of_hosts++;
 130
 131   LIBMEMCACHED_MEMCACHED_SERVER_ADD_END();
 132
 133   return MEMCACHED_SUCCESS;
 134 }
 135
 136 memcached_server_st *memcached_server_list_append(memcached_server_st *ptr,
 137                                                   char *hostname, unsigned int port,
 138                                                   memcached_return *error)
 139 {
 140   unsigned int count;
 141   memcached_server_st *new_host_list;
 142   char *new_hostname;
 143
 144   if (!hostname)
 145     return ptr;
 146
 147   if (!port)
 148     port= MEMCACHED_DEFAULT_PORT;
 149
 150   /* Always count so that we keep a free host at the end */
 151   if (ptr)
 152   {
 153     for (count= 0; ptr[count].hostname; count++);
 154     count+= 2;
 155     new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count);
 156     if (!new_host_list)
 157       goto error;
 158     host_reset(&new_host_list[count-1], NULL, 0, MEMCACHED_CONNECTION_UNKNOWN);
 159   }
 160   else
 161   {
 162     count= 2;
 163     new_host_list= (memcached_server_st *)malloc(sizeof(memcached_server_st) * count);
 164     if (!new_host_list)
 165       goto error;
 166     host_reset(&new_host_list[0], NULL, 0, MEMCACHED_CONNECTION_UNKNOWN);
 167     host_reset(&new_host_list[1], NULL, 0, MEMCACHED_CONNECTION_UNKNOWN);
 168   }
 169
 170   new_hostname= strdup(hostname);
 171
 172   if (!new_hostname)
 173     goto error;
 174
 175   host_reset(&new_host_list[count-2], new_hostname, port, MEMCACHED_CONNECTION_TCP);
 176
 177   *error= MEMCACHED_SUCCESS;
 178   return new_host_list;
 179 error:
 180   *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
 181
 182   return NULL;
 183 }
 184
 185 unsigned int memcached_server_list_count(memcached_server_st *ptr)
 186 {
 187   unsigned int x;
 188
 189   for (x= 0; ptr[x].hostname; x++);
 190
 191   return x;
 192 }
 193
 194 void memcached_server_list_free(memcached_server_st *ptr)
 195 {
 196   unsigned int x;
 197
 198   for (x= 0; ptr[x].hostname; x++)
 199     free(ptr[x].hostname);
 200
 201   free(ptr);
 202 }