void test_key_value()
{
MemPool *pool = NULL;
key_value_t *kv = NULL;
key_value_node_t *node = NULL;
char *keys[5], *vals[5];
pool = mem_pool_create(160); //160M
kv = key_value_init(pool, 20);
keys[0] = "abcde";
vals[0] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
key_value_set(pool, kv, "abcde", strlen("abcde"),
vals[0], strlen(vals[0]), 0);
keys[1] = "qwerty";
vals[1] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
key_value_set(pool, kv, keys[1], strlen(keys[1]),
vals[1], strlen(vals[1]), 0);
keys[2] = "asdf";
vals[2] = "cccccccccccc";
key_value_set(pool, kv, keys[2], strlen(keys[2]),
vals[2], strlen(vals[2]), 0);
node = key_value_get(kv, keys[2], strlen(keys[2]));
printf("get %s node data: %s\n", keys[2], (char *)node->data);
keys[3] = "asdf";
vals[3] = "dddddddddddddddddddddddddddddddddddddddddddddddddddd";
key_value_set(pool, kv, keys[3], strlen(keys[3]),
vals[3], strlen(vals[3]), 0);
node = key_value_get(kv, keys[3], strlen(keys[3]));
printf("get %s node data: %s\n", keys[3], (char *)node->data);
keys[4] = "lkjhgfdsa";
vals[4] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee";
key_value_set(pool, kv, keys[4], strlen(keys[4]),
vals[4], strlen(vals[4]), 0);
node = key_value_get(kv, "aaaa", strlen("aaaa"));
if(node)
printf("get aaaa node data: %s\n", (char *)node->data);
else
printf("get aaaa node data: Not Found\n");
printf("Key Value: used memory: %u, mem pool used memory: %lu \n",
kv->used_memory, pool->used_size);
printf("Key-Value Pairs number: %u\n", kv->count);
key_value_destroy(pool, kv);
mem_pool_destroy(pool);
}
int main(int argc, char **argv) {
PaError err = Pa_Initialize();
if (err != paNoError) {
printf("failed to initialize port audio, %s\n", Pa_GetErrorText(err));
return 1;
}
quiet_lwip_portaudio_driver_config *conf =
calloc(1, sizeof(quiet_lwip_portaudio_driver_config));
const char *encoder_key = "audible-7k-channel-1";
const char *decoder_key = "audible-7k-channel-0";
const char *fname = "/usr/local/share/quiet/quiet-profiles.json";
conf->encoder_opt =
quiet_encoder_profile_filename(fname, encoder_key);
conf->decoder_opt =
quiet_decoder_profile_filename(fname, decoder_key);
conf->encoder_device = Pa_GetDefaultOutputDevice();
const PaDeviceInfo *device_info = Pa_GetDeviceInfo(conf->encoder_device);
conf->encoder_sample_rate = device_info->defaultSampleRate;
conf->encoder_latency = device_info->defaultLowOutputLatency;
conf->decoder_device = Pa_GetDefaultInputDevice();
device_info = Pa_GetDeviceInfo(conf->decoder_device);
conf->decoder_sample_rate = device_info->defaultSampleRate;
conf->decoder_latency = device_info->defaultLowOutputLatency;
conf->encoder_sample_size = 1 << 8;
conf->decoder_sample_size = 1 << 8;
memcpy(conf->hardware_addr, mac, 6);
quiet_lwip_portaudio_interface *interface =
quiet_lwip_portaudio_create(conf, htonl(ipaddr), htonl(netmask), htonl(gateway));
free(conf);
quiet_lwip_portaudio_audio_threads *audio_threads =
quiet_lwip_portaudio_start_audio_threads(interface);
key_value_t *kv = key_value_init();
kv_t temp_kv;
temp_kv.key = calloc(key_len, sizeof(uint8_t));
temp_kv.value = calloc(value_len, sizeof(uint8_t));
int recv_socket = open_recv(ipaddr_s);
size_t buf_len = 4096;
uint8_t *buf = calloc(buf_len, sizeof(uint8_t));
struct sockaddr_in recv_from;
int conn_fd = recv_connection(recv_socket, &recv_from);
printf("received connection from %s\n", inet_ntoa(recv_from.sin_addr.s_addr));
for (;;) {
ssize_t recv_len = read(conn_fd, buf, buf_len);
if (recv_len) {
printf("received packet from %s: %.*s\n", inet_ntoa(recv_from.sin_addr.s_addr), (int)recv_len, buf);
} else {
close(conn_fd);
conn_fd = recv_connection(recv_socket, &recv_from);
printf("received connection from %s\n", inet_ntoa(recv_from.sin_addr.s_addr));
continue;
}
if (recv_len < 0) {
printf("read from connection failed\n");
}
if (memcmp(buf, recv_ping_str, strlen(recv_ping_str)) == 0) {
printf("sending response to %s\n", inet_ntoa(recv_from.sin_addr.s_addr));
memset(buf, 0, buf_len);
memcpy(buf, send_ping_str, strlen(send_ping_str));
write(conn_fd, buf, strlen(send_ping_str));
} else if (memcmp(buf, recv_add_str, strlen(recv_add_str)) == 0) {
ptrdiff_t key_offset = strlen(recv_add_str);
size_t remaining = recv_len - key_offset;
ptrdiff_t value_offset = 0;
for (size_t i = 0; i < (remaining - 1) && i < key_len; i++) {
if (buf[key_offset + i] == add_delim) {
value_offset = key_offset + i + 1;
break;
}
}
if (value_offset) {
memset(temp_kv.key, 0, key_len * sizeof(uint8_t));
memset(temp_kv.value, 0, value_len * sizeof(uint8_t));
memcpy(temp_kv.key, buf + key_offset, value_offset - key_offset - 1);
memcpy(temp_kv.value, buf + value_offset, recv_len - value_offset);
key_value_add(kv, &temp_kv);
key_value_print(kv);
memset(buf, 0, buf_len);
memcpy(buf, send_add_str, strlen(send_add_str));
write(conn_fd, buf, strlen(send_add_str));
}
} else if (memcmp(buf, recv_get_str, strlen(recv_get_str)) == 0) {
ptrdiff_t key_offset = strlen(recv_get_str);
memset(temp_kv.key, 0, key_len * sizeof(uint8_t));
memcpy(temp_kv.key, buf + key_offset, recv_len - key_offset);
const kv_t *found = key_value_find(kv, &temp_kv);
if (found) {
write(conn_fd, found->value, value_len);
} else {
write(conn_fd, get_notfound, strlen(get_notfound));
}
}
}
quiet_lwip_portaudio_stop_audio_threads(audio_threads);
key_value_destroy(kv);
free(buf);
quiet_lwip_portaudio_destroy(interface);
Pa_Terminate();
return 0;
}
