/**
* mds — A micro-display server
* Copyright © 2014, 2015, 2016 Mattias Andrée (maandree@member.fsf.org)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _GNU_SOURCE
# define _GNU_SOURCE
#endif
#include "proto-util.h"
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <stdio.h>
/**
* The number of headers there must be before
* it is beneficial to sort them.
*/
#ifndef LIBMDS_HEADERS_SORT_THRESHOLD
# define LIBMDS_HEADERS_SORT_THRESHOLD 100 /* XXX: Value is chosen at random */
#endif
/**
* The number of headers there must be before
* it is beneficial to copy them, if that
* it required to sort them. Note that this
* value plus that of `LIBMDS_HEADERS_SORT_THRESHOLD`
* is the threshold for copying and sorting
* a header array.
*/
#ifndef LIBMDS_HEADERS_COPY_THRESHOLD
# define LIBMDS_HEADERS_COPY_THRESHOLD 10 /* XXX: Value is chosen at random */
#endif
/**
* The number of headers there must be before
* it is beneficial to search them using binary
* search rather than linear search.
*
* Note that hybrid search is not implemented,
* is is either full binary or full linear.
*/
#ifndef LIBMDS_HEADERS_BINSEARCH_THRESHOLD
# define LIBMDS_HEADERS_BINSEARCH_THRESHOLD 1000 /* XXX: Value is chosen at semirandom */
#endif
/**
* Variant of `strcmp` that regards the first string as
* ending at the first occurrence of the substring ": "
*
* @param header_a The header that may include a value
* @param header_b The header that may not include a value
* @return Same syntax as strcmp(3)
*/
static int
headercmp(const char *header_a, const char *header_b)
{
int a, b;
for (;;) {
a = (int)*header_a++;
b = (int)*header_b++;
if (a == ':' && *header_a == ' ')
return 0 - b;
if (!a || !b)
return a - b;
if (a - b)
return a - b;
}
}
/**
* Variant for `headercmp` where the arguments are pointers to the
* values that should be compared, and the second parameter is
* treated the same way as the first parameter
*
* @param strp_a Pointer to the first string
* @param strp_b Pointer to the second string
* @return Will return `strcmp(*strp_a, *strp_b)`, see strcmp(3)
*/
static int
headerpcmp(const void *headerp_a, const void *headerp_b)
{
const char *header_a = *(char *const *)headerp_a;
const char *header_b = *(char *const *)headerp_b;
int a, b, az, bz;
for (;;) {
a = (int)*header_a++;
b = (int)*header_b++;
az = a == ':' && *header_a == ' ';
bz = b == ':' && *header_b == ' ';
if (az)
return 0 - !(bz || !b);
if (bz)
return a - 0;
if (!a || !b)
return a - b;
if (a - b)
return a - b;
}
}
/**
* Cherrypick headers from a message
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param found Output parameter for the number of found headers of those that
* where requested. `NULL` is permitted.
* @param optimisation Optimisations the function may use, only one value please
* @param ... The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return Zero on success, -1 on error, `errno` will have been set
* accordingly on error.
*
* @throws ENOMEM Out of memory, Possibly, the process hit the RLIMIT_AS or
* RLIMIT_DATA limit described in getrlimit(2).
*/
int
libmds_headers_cherrypick(char **restrict headers, size_t header_count, size_t *restrict found,
libmds_cherrypick_optimisation_t optimisation, ...)
{
va_list args;
int r, saved_errno;
va_start(args, optimisation);
r = libmds_headers_cherrypick_v(headers, header_count, found, optimisation, args);
saved_errno = errno;
va_end(args);
errno = saved_errno;
return r;
}
/**
* Cherrypick headers from a message,
* linear search will be used without optimisation
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param ... The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_linear_unsorted(char **restrict headers, size_t header_count, ...)
{
va_list args;
size_t r;
int saved_errno;
va_start(args, header_count);
r = libmds_headers_cherrypick_linear_unsorted_v(headers, header_count, args);
saved_errno = errno;
va_end(args);
errno = saved_errno;
return r;
}
/**
* Cherrypick headers from a message,
* linear search will be used with optimisation based on that the array is sorted
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param ... The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t libmds_headers_cherrypick_linear_sorted(char **restrict headers, size_t header_count, ...)
{
va_list args;
size_t r;
int saved_errno;
va_start(args, header_count);
r = libmds_headers_cherrypick_linear_sorted_v(headers, header_count, args);
saved_errno = errno;
va_end(args);
errno = saved_errno;
return r;
}
/**
* Cherrypick headers from a message,
* binary search will be used
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param ... The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_binary_unsorted(char **restrict headers, size_t header_count, ...)
{
va_list args;
size_t r;
int saved_errno;
va_start(args, header_count);
r = libmds_headers_cherrypick_binary_unsorted_v(headers, header_count, args);
saved_errno = errno;
va_end(args);
errno = saved_errno;
return r;
}
/**
* Cherrypick headers from a message,
* binary search will be used with optimisation based on
* that list of requested headers (`...`) is sorted
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param ... The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_binary_sorted(char **restrict headers, size_t header_count, ...)
{
va_list args;
size_t r;
int saved_errno;
va_start(args, header_count);
r = libmds_headers_cherrypick_binary_sorted_v(headers, header_count, args);
saved_errno = errno;
va_end(args);
errno = saved_errno;
return r;
}
/**
* Cherrypick headers from a message
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param found Output parameter for the number of found headers of those that
* were requested. `NULL` is permitted.
* @param optimisation Optimisations the function may use, only one value please
* @param args The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return Zero on success, -1 on error, `errno` will have been set
* accordingly on error.
*
* @throws ENOMEM Out of memory, Possibly, the process hit the RLIMIT_AS or
* RLIMIT_DATA limit described in getrlimit(2).
*/
int
libmds_headers_cherrypick_v(char **restrict headers, size_t header_count, size_t *restrict found,
libmds_cherrypick_optimisation_t optimisation, va_list args)
{
char **headers_ = headers;
size_t found_;
libmds_cherrypick_optimisation_t sorted;
if (found)
*found = 0;
optimisation ^= sorted = optimisation & ARGS_SORTED;
if (optimisation == DO_NOT_SORT) {
if (header_count >= LIBMDS_HEADERS_SORT_THRESHOLD + LIBMDS_HEADERS_COPY_THRESHOLD) {
headers_ = malloc(header_count * sizeof(char*));
if (!headers_)
return -1;
memcpy(headers_, headers, header_count * sizeof(char*));
libmds_headers_sort(headers_, header_count);
optimisation = SORTED;
}
} else if (optimisation == SORT) {
if (header_count >= LIBMDS_HEADERS_SORT_THRESHOLD) {
libmds_headers_sort(headers_, header_count);
optimisation = SORTED;
}
}
if (optimisation != SORTED) {
found_ = libmds_headers_cherrypick_linear_unsorted_v(headers_, header_count, args);
} else if (header_count < LIBMDS_HEADERS_BINSEARCH_THRESHOLD) {
if (sorted)
found_ = libmds_headers_cherrypick_linear_sorted_v(headers_, header_count, args);
else
found_ = libmds_headers_cherrypick_linear_unsorted_v(headers_, header_count, args);
} else if (sorted) {
found_ = libmds_headers_cherrypick_binary_sorted_v(headers_, header_count, args);
} else {
found_ = libmds_headers_cherrypick_binary_unsorted_v(headers_, header_count, args);
}
if (found)
*found = found_;
if (headers_ != headers)
free(headers_);
return 0;
}
/**
* Cherrypick headers from a message,
* linear search will be used without optimisation
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param args The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_linear_unsorted_v(char **restrict headers, size_t header_count, va_list args)
{
const char *header;
char **value_out;
size_t found = 0, i;
for (;;) {
header = va_arg(args, const char*);
if (!header)
return found;
value_out = va_arg(args, char**);
*value_out = NULL;
for (i = 0; i < header_count; i++) {
if (!headercmp(headers[i], header)) {
*value_out = strstr(headers[i], ": ") + 2;
found++;
break;
}
}
}
}
/**
* Cherrypick headers from a message,
* linear search will be used with optimisation based
* on that the array is sorted as well as the list of
* requested headers (`args`)
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param args The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_linear_sorted_v(char **restrict headers, size_t header_count, va_list args)
{
const char *header;
char **value_out;
size_t found = 0, i = 0;
int r;
for (;;) {
header = va_arg(args, const char*);
if (!header)
return found;
value_out = va_arg(args, char**);
*value_out = NULL;
for (; i < header_count; i++) {
r = headercmp(headers[i], header);
if (!r) {
*value_out = strstr(headers[i], ": ") + 2;
found++, i++;
break;
}
if (r > 0)
break;
}
}
}
/**
* Cherrypick headers from a message,
* binary search will be used
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param args The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_binary_unsorted_v(char **restrict headers, size_t header_count, va_list args)
{
const char *header;
char **value_out;
void *found_element;
size_t found = 0;
for (;;) {
header = va_arg(args, const char*);
if (!header)
return found;
value_out = va_arg(args, char**);
*value_out = NULL;
found_element = bsearch(&header, headers, header_count, sizeof(char*), headerpcmp);
if (found_element)
*value_out = strstr(*(char**)found_element, ": ") + 2, found++;
}
}
/**
* Cherrypick headers from a message,
* binary search will be used with optimisation based on
* that list of requested headers (`args`) is sorted
*
* @param headers The headers in the message
* @param header_count The number of headers
* @param args The first argument should be the name of a header, it should
* have the type `const char*`. The second argument should be
* a pointer to the location where the header named by the first
* argument in the argument list names. It should have the type
* `char**`. If the header is found, its value will be stored,
* and it will be a NUL-terminated string. If the header is not
* found, `NULL` will be stored. The next two arguments is
* interpreted analogously to the first two arguments, and the
* following two in the same way, and so on. When there are no
* more headers in the list, it should be terminated with a `NULL`.
* @return The number of found headers of those that were requested
*/
size_t
libmds_headers_cherrypick_binary_sorted_v(char **restrict headers, size_t header_count, va_list args)
{
const char *header;
char **value_out;
void *found_element;
size_t found = 0;
size_t offset = 0;
/* I sincerely doubt even this amount of optimisation is needed,
* so there is no need for even faster algorithms, keep in mind
* that the overhead increases with faster algorithms. */
for (;;) {
header = va_arg(args, const char*);
if (!header)
return found;
value_out = va_arg(args, char**);
*value_out = NULL;
found_element = bsearch(&header, headers + offset, header_count - offset, sizeof(char *), headerpcmp);
if (found_element) {
offset = (size_t)((char **)found_element - headers);
*value_out = strstr(*(char **)found_element, ": ") + 2;
found++;
}
}
}
/**
* Sort the a header array, this is what `libmds_headers_cherrypick`
* uses to optimise its procedure.
*
* @param headers The array of headers
* @param headr_count The number of elements in `headers`
*/
void
libmds_headers_sort(char **restrict headers, size_t header_count)
{
qsort(headers, header_count, sizeof(char *), headerpcmp);
}
/**
* Compose a message
*
* @param buffer Pointer to the buffer where the message should be written,
* may point to `NULL` if `buffer_size` points to zero, but the
* pointer itself must not be `NULL`. The buffer may be reallocated.
* Will be updated with the new buffer it is allocated.
* The buffer the pointer points to will be filled with the
* message, however there is no guarantee it will be NUL-terminated.
* @param buffer_size The allocation size, in `char`, of `*buffer`, if and only if `buffer`
* points to `NULL`, this point should point to zero, and vice versa.
* Must not be `NULL`. Will be update with the new allocation size.
* It is guaranteed that there will be remove to NUL-terminate
* the message even if it was already NUL-terminate (terminate it
* doubly in that case.)
* @param length Output parameter for the length of the constructed message.
* Must not be `NULL`.
* @param payload The payload that should be added to the message, it should end
* with a LF. `NULL` if the message should not have a payload.
* @param payload_length Pointer to the length of the payload. If `NULL`, `payload`
* must be NUL-terminated, and if it is `NULL` this NUL-termination
* will be used to find the length of the payload. This variable is
* not used if `payload` is `NULL`.
* @param ... The first argument should be a line describing the first header,
* it should be a printf(3)-formatted line that fully describes the
* header line, that is, the header name, colon, blank space and then
* the header's value. No LF should be included. The following
* arguments should be the argument to format the header line.
* If a format for a line begins with a question mark, the remainder
* of the line used, but only if the next argument is non-zero
* (it should be of type `int`,) that argument will not be used
* for the formatting. This may be be iterated any number of this.
* The last argument should be `NULL` to specify that there are no
* more headers. The `Length`-header should not be included, it is
* added automatically. A header may not have a length larger than
* 2¹⁵, otherwise the behaviour of this function is undefined.
* @return Zero on success, -1 on error, `errno` will have been set
* accordingly on error.
*
* @throws ENOMEM Out of memory, Possibly, the process hit the RLIMIT_AS or
* RLIMIT_DATA limit described in getrlimit(2).
*/
int
libmds_compose(char **restrict buffer, size_t *restrict buffer_size, size_t *restrict length,
const char *restrict payload, const size_t *restrict payload_length, ...)
{
va_list args;
int r, saved_errno;
va_start(args, payload_length);
r = libmds_compose_v(buffer, buffer_size, length, payload, payload_length, args);
saved_errno = errno;
va_end(args);
errno = saved_errno;
return r;
}
/**
* Compose a message
*
* @param buffer Pointer to the buffer where the message should be written,
* may point to `NULL` if `buffer_size` points to zero, but the
* pointer itself must not be `NULL`. The buffer may be reallocated.
* Will be updated with the new buffer it is allocated.
* The buffer the pointer points to will be filled with the
* message, however there is no guarantee it will be NUL-terminated.
* @param buffer_size The allocation size, in `char`, of `*buffer`, if and only if `buffer`
* points to `NULL`, this point should point to zero, and vice versa.
* Must not be `NULL`. Will be update with the new allocation size.
* It is guaranteed that there will be remove to NUL-terminate
* the message even if it was already NUL-terminate (terminate it
* doubly in that case.)
* @param length Output parameter for the length of the constructed message.
* Must not be `NULL`.
* @param payload The payload that should be added to the message, it should end
* with a LF. `NULL` if the message should not have a payload.
* @param payload_length Pointer to the length of the payload. If `NULL`, `payload`
* must be NUL-terminated, and if it is `NULL` this NUL-termination
* will be used to find the length of the payload. This variable is
* not used if `payload` is `NULL`.
* @param args The first argument should be a line describing the first header,
* it should be a printf(3)-formatted line that fully describes the
* header line, that is, the header name, colon, blank space and then
* the header's value. No LF should be included. The following
* arguments should be the argument to format the header line.
* If a format for a line begins with a question mark, the remainder
* of the line used, but only if the next argument is non-zero
* (it should be of type `int`,) that argument will not be used
* for the formatting. This may be be iterated any number of this.
* The last argument should be `NULL` to specify that there are no
* more headers. The `Length`-header should not be included, it is
* added automatically. A header may not have a length larger than
* 2¹⁵, otherwise the behaviour of this function is undefined.
* @return Zero on success, -1 on error, `errno` will have been set
* accordingly on error.
*
* @throws ENOMEM Out of memory, Possibly, the process hit the RLIMIT_AS or
* RLIMIT_DATA limit described in getrlimit(2).
*/
int
libmds_compose_v(char **restrict buffer, size_t *restrict buffer_size, size_t *restrict length,
const char *restrict payload, const size_t *restrict payload_length, va_list args)
{
char *buf = *buffer;
size_t bufsize = *buffer_size;
size_t len = 0;
int part_len;
char *part_msg;
size_t payload_len = 0;
const char* format;
int include;
int saved_errno;
*length = 0;
if (payload)
payload_len = payload_length == NULL ? strlen(payload) : *payload_length;
if (!bufsize) {
bufsize = 128;
buf = realloc(buf, bufsize * sizeof(char));
if (!buf)
return -1;
}
for (;;) {
format = va_arg(args, const char*);
if (!format)
break;
include = 1;
if (*format == '?') {
include = va_arg(args, int);
format++;
}
#if defined(__GNUC__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wformat-nonliteral"
# pragma GCC diagnostic ignored "-Wsuggest-attribute=format"
#endif
part_len = vasprintf(&part_msg, format, args);
/* XXX vbprintf in slibc will be a nice replacement for this horror. */
#if defined(__GNUC__)
# pragma GCC diagnostic pop
#endif
if (!include) {
if (part_len >= 0)
free(part_msg);
continue;
}
if (part_len < 0)
return -1;
if (len + (size_t)part_len >= bufsize) {
*buffer_size = bufsize;
*buffer = buf;
do
bufsize <<= 1;
while (len + (size_t)part_len >= bufsize);
buf = realloc(buf, bufsize * sizeof(char));
if (!buf)
return saved_errno = errno, free(part_msg), errno = saved_errno, -1;
}
memcpy(buf + len, part_msg, ((size_t)part_len) * sizeof(char));
len += (size_t)part_len;
buf[len++] = '\n';
free(part_msg);
}
#define LENGTH_LEN \
(payload_len > 0 ? ((sizeof("Length: \n") / sizeof(char) - 1) + 3 * sizeof(size_t)) : 0)
if (len + LENGTH_LEN + 1 + payload_len + 1 > bufsize) {
*buffer_size = bufsize;
*buffer = buf;
bufsize = len + LENGTH_LEN + 1 + payload_len + 1;
buf = realloc(buf, bufsize * sizeof(char));
if (!buf)
return -1;
}
#undef LENGTH_LEN
if (payload_len > 0)
sprintf(buf + len, "Length: %zu\n%n", payload_len, &part_len),
len += (size_t)part_len;
buf[len++] = '\n';
if (payload_len > 0)
memcpy(buf + len, payload, payload_len * sizeof(char)),
len += payload_len;
*buffer_size = bufsize;
*buffer = buf;
*length = len;
return 0;
}
/**
* Increase the message ID counter
*
* @param message_id Pointer to the current message ID, will be update with
* the next free message ID. Must not be `NULL`.
* @param test Function that tests whether an message ID is free,
* it takes the message ID to test as its first argument,
* and `data` as its second argument, and returns zero if
* it is in used, a positive integer if it is free, and a
* negative integer if an error occurred. `NULL` if there
* should be no testing.
* @param data Argument to pass to `test` so that it can deal with
* threading or any other issues. Unused if `test` is `NULL`.
* @return Zero on success, -1 on error, `errno` will have been set
* accordingly on error.
*
* @throws EAGAIN If there are no free message ID to be used.
* It is advisable to make `test` throw this immediately if
* there are no free message ID:s.
* @throws Any error that `test` may throw.
*/
int
libmds_next_message_id(uint32_t *restrict message_id,
int (*test)(uint32_t message_id, void *data), void *data)
{
uint32_t id = *message_id;
uint32_t first_test;
int r;
id = id == UINT32_MAX ? 0 : (id + 1);
if (test) {
for (first_test = id;;) {
r = test(id, data);
if (r < 0)
return -1;
if (r)
break;
id = id == UINT32_MAX ? 0 : (id + 1);
if (id == first_test)
return errno = EAGAIN, -1;
}
}
*message_id = id;
return 0;
}
