static memcached_return server_add(memcached_st *ptr, const char *hostname, unsigned int port, uint32_t weight, memcached_connection type) { memcached_server_st *new_host_list; if ( (ptr->flags & MEM_USE_UDP && type != MEMCACHED_CONNECTION_UDP) || ( (type == MEMCACHED_CONNECTION_UDP) && !(ptr->flags & MEM_USE_UDP) ) ) return MEMCACHED_INVALID_HOST_PROTOCOL; new_host_list= ptr->call_realloc(ptr, ptr->hosts, sizeof(memcached_server_st) * (ptr->number_of_hosts+1)); if (new_host_list == NULL) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; ptr->hosts= new_host_list; /* TODO: Check return type */ (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], hostname, port, weight, type); ptr->number_of_hosts++; ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts; return run_distribution(ptr); }
static memcached_return_t server_add(memcached_st *ptr, const char *hostname, in_port_t port, uint32_t weight, memcached_connection_t type) { memcached_server_st *new_host_list; memcached_server_write_instance_st instance; if ( (ptr->flags.use_udp && type != MEMCACHED_CONNECTION_UDP) || ( (type == MEMCACHED_CONNECTION_UDP) && (! ptr->flags.use_udp) ) ) return MEMCACHED_INVALID_HOST_PROTOCOL; new_host_list= libmemcached_realloc(ptr, memcached_server_list(ptr), sizeof(memcached_server_st) * (ptr->number_of_hosts + 1)); if (new_host_list == NULL) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; memcached_server_list_set(ptr, new_host_list); /* TODO: Check return type */ instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr)); (void)memcached_server_create_with(ptr, instance, hostname, port, weight, type); ptr->number_of_hosts++; instance= memcached_server_instance_fetch(ptr, 0); memcached_servers_set_count(instance, memcached_server_count(ptr)); return run_distribution(ptr); }
memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_server_list_st list) { uint32_t count; memcached_server_st *new_host_list; uint32_t x; if (! list) return MEMCACHED_SUCCESS; count= memcached_server_list_count(list); new_host_list= libmemcached_realloc(ptr, memcached_server_list(ptr), sizeof(memcached_server_st) * (count + memcached_server_count(ptr))); if (! new_host_list) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; memcached_server_list_set(ptr, new_host_list); for (x= 0; x < count; x++) { memcached_server_write_instance_st instance; if ((ptr->flags.use_udp && list[x].type != MEMCACHED_CONNECTION_UDP) || ((list[x].type == MEMCACHED_CONNECTION_UDP) && ! (ptr->flags.use_udp)) ) return MEMCACHED_INVALID_HOST_PROTOCOL; WATCHPOINT_ASSERT(list[x].hostname[0] != 0); instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr)); /* TODO check return type */ (void)memcached_server_create_with(ptr, instance, list[x].hostname, list[x].port, list[x].weight, list[x].type); ptr->number_of_hosts++; } /* Provides backwards compatibility with server list. */ { memcached_server_write_instance_st instance; instance= memcached_server_instance_fetch(ptr, 0); instance->number_of_hosts= memcached_server_count(ptr); } return run_distribution(ptr); }
memcached_server_list_st memcached_server_list_append_with_weight(memcached_server_list_st ptr, const char *hostname, in_port_t port, uint32_t weight, memcached_return_t *error) { uint32_t count; memcached_server_list_st new_host_list; if (hostname == NULL || error == NULL) return NULL; if (! port) port= MEMCACHED_DEFAULT_PORT; /* Increment count for hosts */ count= 1; if (ptr != NULL) { count+= memcached_server_list_count(ptr); } new_host_list= (memcached_server_write_instance_st)realloc(ptr, sizeof(memcached_server_st) * count); if (!new_host_list) { *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE; return NULL; } /* TODO: Check return type */ memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP); /* Backwards compatibility hack */ memcached_servers_set_count(new_host_list, count); *error= MEMCACHED_SUCCESS; return new_host_list; }
memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr, const char *hostname, unsigned int port, uint32_t weight, memcached_return *error) { unsigned int count; memcached_server_st *new_host_list; if (hostname == NULL || error == NULL) return NULL; if (!port) port= MEMCACHED_DEFAULT_PORT; /* Increment count for hosts */ count= 1; if (ptr != NULL) { count+= ptr[0].count; } new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count); if (!new_host_list) { *error= MEMCACHED_MEMORY_ALLOCATION_FAILURE; return NULL; } /* TODO: Check return type */ memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP); /* Backwards compatibility hack */ new_host_list[0].count= (uint16_t) count; *error= MEMCACHED_SUCCESS; return new_host_list; }
memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list) { unsigned int x; uint16_t count; memcached_server_st *new_host_list; if (!list) return MEMCACHED_SUCCESS; count= list[0].count; new_host_list= ptr->call_realloc(ptr, ptr->hosts, sizeof(memcached_server_st) * (count + ptr->number_of_hosts)); if (!new_host_list) return MEMCACHED_MEMORY_ALLOCATION_FAILURE; ptr->hosts= new_host_list; for (x= 0; x < count; x++) { if ((ptr->flags & MEM_USE_UDP && list[x].type != MEMCACHED_CONNECTION_UDP) || ((list[x].type == MEMCACHED_CONNECTION_UDP) && ! (ptr->flags & MEM_USE_UDP)) ) return MEMCACHED_INVALID_HOST_PROTOCOL; WATCHPOINT_ASSERT(list[x].hostname[0] != 0); memcached_server_create(ptr, &ptr->hosts[ptr->number_of_hosts]); /* TODO check return type */ (void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], list[x].hostname, list[x].port, list[x].weight, list[x].type); ptr->number_of_hosts++; } ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts; return run_distribution(ptr); }