void chat(int fd)
{
char msgb[255];
pthread_t tid;
void * thread_arg;
int err;
thread_arg=(void *)fd;
err = pthread_create(&tid, NULL, chat_thread_func_to_write, thread_arg );
if(err != 0)
{
printf("can't create thread: %s\n", strerror(err));
}
err = pthread_detach(tid);
if(err != 0)
{
printf("can't detach thread: %s\n", strerror(err));
}
printf("Enter Something and then wait for response\n");
for(;;)
{
if((recv(fd,msgb,sizeof(msgb),0)) <= 0) //receiving username
{
errorp("peerserver>login_check",0,0,"recv username");
return 0;
}
printf("%s", msgb);
}
}
void merge_nodes(int **adj_list, int *lengths, int adj_list_len, int node_1, int node_2)
{
int node_1_len;
adj_list[node_1] = realloc(adj_list[node_1], (lengths[node_1] + lengths[node_2]) * sizeof(*adj_list[node_1]));
if(adj_list[node_1] != NULL)
{
node_1_len = lengths[node_1];
lengths[node_1] += lengths[node_2];
}
else
errorp("realloc, adj_list[node_1]");
/* copy connections from node_2 to node_1 */
int i;
for(i = 0; i < lengths[node_2]; ++i)
adj_list[node_1][node_1_len + i] = adj_list[node_2][i];
/* remove node_2 */
adj_list[node_2] = realloc(adj_list[node_2], 0);
lengths[node_2] = 0;
/* remove self loops */
for(i = 0; i < lengths[node_1]; ++i)
if(adj_list[node_1][i] == node_1 || adj_list[node_1][i] == node_2)
{
while(adj_list[node_1][ lengths[node_1] - 1 ] == node_1 || adj_list[node_1][ lengths[node_1] - 1 ] == node_2)
--lengths[node_1];
if(lengths[node_1] <= i)
break;
swap_elem(adj_list[node_1], i, lengths[node_1] - 1);
--lengths[node_1];
}
adj_list[node_1] = realloc(adj_list[node_1], lengths[node_1] * sizeof(*adj_list[node_1]));
if(adj_list[node_1] == NULL)
errorp("realloc, adj_list[node_1]");
/* replace connections to node_2 to node_1 */
int j;
for(i = 0; i < adj_list_len; ++i)
if(i != node_1 && i != node_2)
for(j = 0; j < lengths[i]; ++j)
if(adj_list[i][j] == node_2)
adj_list[i][j] = node_1;
}
int main(int argc, char **argv) {
pa_proplist *proplist = NULL;
pa_mainloop *m = NULL;
pa_mainloop_api *api = NULL;
pa_context *context = NULL;
struct context *ctx;
struct audio_file *file;
int ret;
ctx = malloc(sizeof(struct context));
if (!ctx) {
errorp("Couldn't allocate async callbacks context");
goto quit;
}
memset(ctx, 0, sizeof(*ctx));
file = audio_file_new("samples/sample.wav");
if (!file)
goto quit;
proplist = pa_proplist_new();
if (!proplist) {
error("Couldn't create a PulseAudio property list");
goto quit;
}
pa_proplist_sets(proplist, PA_PROP_APPLICATION_NAME, "malicious-client-kill-server");
m = pa_mainloop_new();
if (!m) {
error("Couldn't create PulseAudio mainloop");
goto quit;
}
api = pa_mainloop_get_api(m);
context = pa_context_new_with_proplist(api, NULL, proplist);
if (!context) {
error("Couldn't create client context");
goto quit;
}
ctx->file = file;
ctx->mainloop_api = api;
ctx->context = context;
pa_context_set_state_callback(context, context_state_callback, ctx);
ret = pa_context_connect(context, NULL, 0, NULL);
if (ret < 0) {
error ("Couldn't connect to PulseAudio server: %s",
pa_strerror(pa_context_errno(context)));
goto quit;
}
pa_mainloop_run(m, &ret);
return ret;
quit:
exit(EXIT_FAILURE);
}
// Query - sends query and waits for result (client side)
int double_queue_query_err(
double_queue_t *q,
void * query, size_t query_length,
void ** result, size_t *result_length,
int *exit_after_signal,
long source, long destination,
int (*error_f)(void*), void *error_a) {
// Parameter checks
if(query_length > 1024 /* maksymalna długość komunikatu */) {
error("Too long message.");
return error_f(error_a);
}
// Prepare query
void * real_query = NULL;
size_t real_query_length;
char * res = NULL;
char * answer_buffer = malloc(1024+sizeof(long));
if(answer_buffer == NULL)
goto allocation_failed;
if(combine(&real_query, &real_query_length, "%l %b %l", destination, query, query_length, source) != 0)
goto allocation_failed;
// Send query
resend:
if(msgsnd(q->id1, real_query, real_query_length - sizeof(long), 0) == -1) {
if(errno == EINTR) {
log("Interrupted during waiting...");
if(*exit_after_signal) {
free(real_query);
free(answer_buffer);
return DOUBLE_QUEUE_INTERRUPTED;
} else {
goto resend;
}
}
errorp();
free(real_query);
free(answer_buffer);
return error_f(error_a);
}
free(real_query);
// Wait for result
int ret;
rerecv:
ret = msgrcv(q->id2, answer_buffer, 1024+sizeof(long) /* nie potrzebujemy adresu zwrotnego */, source, 0);
if(ret == -1 && errno == EINTR) {
log("Message receiving interrupted.");
if(*exit_after_signal) {
free(answer_buffer);
return DOUBLE_QUEUE_INTERRUPTED;
} else {
goto rerecv;
}
}
if(ret == -1 || ret == 0) {
errorp();
free(answer_buffer);
return error_f(error_a);
}
res = malloc(ret);
if(res == NULL)
goto allocation_failed;
memcpy(res, answer_buffer+sizeof(long), ret);
(*result) = res;
(*result_length) = ret;
free(answer_buffer);
return 0;
allocation_failed:
if(real_query) free(real_query);
if(answer_buffer) free(answer_buffer);
if(res) free(res);
error("Allocation failed.");
return error_f(error_a);
}
struct audio_file *audio_file_new(char *filepath) {
struct audio_file *file = NULL;
struct stat filestat = { 0, };
struct wave_header *header = NULL;
pa_sample_format_t sample_format;
size_t header_size, audio_size;
int fd = -1, ret;
file = malloc(sizeof(struct audio_file));
if (!file)
goto fail;
memset(file, 0, sizeof(*file));
fd = open(filepath, O_RDONLY);
if (fd < 0) {
errorp("open('%s')", filepath);
goto fail;
}
ret = fstat(fd, &filestat);
if (ret < 0) {
errorp("fstat('%s')", filepath);
goto fail;
}
header_size = sizeof(struct wave_header);
if (filestat.st_size < header_size) {
error("Too small file size < WAV header %lu bytes", header_size);
goto fail;
}
header = mmap(NULL, filestat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
if (header == MAP_FAILED) {
errorp("mmap('%s')", filepath);
goto fail;
}
if (strncmp(header->id, "RIFF", 4)) {
error("File '%s' is not a WAV file", filepath);
goto fail;
}
if (header->audio_format != 1) {
error("Cannot play audio file '%s'", filepath);
error("Audio data is not in raw, uncompressed, PCM format");
goto fail;
}
sample_format = bits_per_sample_to_pa_spec_format(header->bits_per_sample);
if (sample_format == PA_SAMPLE_INVALID) {
error("Unrecognized WAV file format with %u bits per sample!",
header->bits_per_sample);
goto fail;
}
/* Guard against corrupted WAV files where the reported audio
* data size is much larger than what's really in the file. */
audio_size = min((size_t)header->audio_data_size,
(filestat.st_size - header_size));
file->buf = (void *)(header + 1);
file->size = audio_size;
file->readi = 0;
file->spec.format = sample_format;
file->spec.rate = header->frequency;
file->spec.channels = header->channels;
return file;
fail:
if (header && header != MAP_FAILED) {
assert(filestat.st_size > 0);
munmap(header, filestat.st_size);
}
if (fd != -1)
close(fd);
if (file)
free(file);
return NULL;
}
