/**
* Stack a decoder instance on top of another.
*
* @param sess The session holding the protocol decoder instances.
* @param di_bottom The instance on top of which di_top will be stacked.
* @param di_top The instance to go on top.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.3.0
*/
SRD_API int srd_inst_stack(struct srd_session *sess,
struct srd_decoder_inst *di_bottom,
struct srd_decoder_inst *di_top)
{
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return SRD_ERR_ARG;
}
if (!di_bottom || !di_top) {
srd_err("Invalid from/to instance pair.");
return SRD_ERR_ARG;
}
if (g_slist_find(sess->di_list, di_top)) {
/* Remove from the unstacked list. */
sess->di_list = g_slist_remove(sess->di_list, di_top);
}
/* Stack on top of source di. */
di_bottom->next_di = g_slist_append(di_bottom->next_di, di_top);
srd_dbg("Stacked %s on top of %s.", di_top->inst_id, di_bottom->inst_id);
return SRD_OK;
}
/** @private */
SRD_PRIV void srd_inst_free_all(struct srd_session *sess)
{
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return;
}
g_slist_free_full(sess->di_list, (GDestroyNotify)srd_inst_free);
}
/* This function behaves exactly like read(). The only difference is
* that it accepts the gnutls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
uint8_t * data, size_t data_size, void* seq,
unsigned int ms)
{
int ret;
if ((type != GNUTLS_ALERT && type != GNUTLS_HEARTBEAT) && (data_size == 0 || data == NULL))
return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
switch(session->internals.recv_state)
{
case RECV_STATE_DTLS_RETRANSMIT:
ret = _dtls_retransmit(session);
if (ret < 0)
return gnutls_assert_val(ret);
session->internals.recv_state = RECV_STATE_0;
case RECV_STATE_0:
_dtls_async_timer_check(session);
/* If we have enough data in the cache do not bother receiving
* a new packet. (in order to flush the cache)
*/
ret = check_buffers (session, type, data, data_size, seq);
if (ret != 0)
return ret;
ret = _gnutls_recv_in_buffers(session, type, htype, ms);
if (ret < 0 && ret != GNUTLS_E_SESSION_EOF)
return gnutls_assert_val(ret);
return check_buffers (session, type, data, data_size, seq);
default:
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
}
}
struct session *sesssion_load(unsigned const char key[KDF_HASH_LEN])
{
struct session *session = session_new();
session->uid = config_read_encrypted_string("session_uid", key);
session->sessionid = config_read_encrypted_string("session_sessionid", key);
session->token = config_read_encrypted_string("session_token", key);
session->private_key.len = config_read_encrypted_buffer("session_privatekey", &session->private_key.key, key);
mlock(session->private_key.key, session->private_key.len);
if (session_is_valid(session))
return session;
else {
session_free(session);
return NULL;
}
}
/**
* Set a metadata configuration key in a session.
*
* @param sess The session to configure.
* @param key The configuration key (SRD_CONF_*).
* @param data The new value for the key, as a GVariant with GVariantType
* appropriate to that key. A floating reference can be passed
* in; its refcount will be sunk and unreferenced after use.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.3.0
*/
SRD_API int srd_session_metadata_set(struct srd_session *sess, int key,
GVariant *data)
{
GSList *l;
int ret;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return SRD_ERR_ARG;
}
if (!key) {
srd_err("Invalid key.");
return SRD_ERR_ARG;
}
if (!data) {
srd_err("Invalid value.");
return SRD_ERR_ARG;
}
/* Hardcoded to samplerate/uint64 for now. */
if (key != SRD_CONF_SAMPLERATE) {
srd_err("Unknown config key %d.", key);
return SRD_ERR_ARG;
}
if (!g_variant_is_of_type(data, G_VARIANT_TYPE_UINT64)) {
srd_err("Invalid value type: expected uint64, got %s",
g_variant_get_type_string(data));
return SRD_ERR_ARG;
}
srd_dbg("Setting session %d samplerate to %"PRIu64".",
sess->session_id, g_variant_get_uint64(data));
ret = SRD_OK;
for (l = sess->di_list; l; l = l->next) {
if ((ret = srd_inst_send_meta(l->data, key, data)) != SRD_OK)
break;
}
g_variant_unref(data);
return ret;
}
/**
* Find a decoder instance by its instance ID.
*
* This will recurse to find the instance anywhere in the stack tree of the
* given session.
*
* @param sess The session holding the protocol decoder instance.
* @param inst_id The instance ID to be found.
*
* @return Pointer to struct srd_decoder_inst, or NULL if not found.
*
* @since 0.3.0
*/
SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess,
const char *inst_id)
{
GSList *l;
struct srd_decoder_inst *tmp, *di;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return NULL;
}
di = NULL;
for (l = sess->di_list; l; l = l->next) {
tmp = l->data;
if ((di = srd_inst_find_by_id_stack(inst_id, tmp)) != NULL)
break;
}
return di;
}
/**
* Register/add a decoder output callback function.
*
* The function will be called when a protocol decoder sends output back
* to the PD controller (except for Python objects, which only go up the
* stack).
*
* @param sess The output session in which to register the callback.
* @param output_type The output type this callback will receive. Only one
* callback per output type can be registered.
* @param cb The function to call. Must not be NULL.
* @param cb_data Private data for the callback function. Can be NULL.
*
* @since 0.3.0
*/
SRD_API int srd_pd_output_callback_add(struct srd_session *sess,
int output_type, srd_pd_output_callback cb, void *cb_data)
{
struct srd_pd_callback *pd_cb;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return SRD_ERR_ARG;
}
srd_dbg("Registering new callback for output type %d.", output_type);
pd_cb = g_malloc(sizeof(struct srd_pd_callback));
pd_cb->output_type = output_type;
pd_cb->cb = cb;
pd_cb->cb_data = cb_data;
sess->callbacks = g_slist_append(sess->callbacks, pd_cb);
return SRD_OK;
}
/**
* Send a chunk of logic sample data to a running decoder session.
*
* If no channel map has been set up, the logic samples must be arranged
* in channel order, in the least amount of space possible. The default
* channel set consists of all required channels + all optional channels.
*
* The size of a sample in inbuf is 'unitsize' bytes. If no channel map
* has been configured, it is the minimum number of bytes needed to store
* the default channels.
*
* @param sess The session to use.
* @param start_samplenum The sample number of the first sample in this chunk.
* @param end_samplenum The sample number of the last sample in this chunk.
* @param inbuf Pointer to sample data.
* @param inbuflen Length in bytes of the buffer.
* @param unitsize The number of bytes per sample.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.4.0
*/
SRD_API int srd_session_send(struct srd_session *sess,
uint64_t start_samplenum, uint64_t end_samplenum,
const uint8_t *inbuf, uint64_t inbuflen, uint64_t unitsize)
{
GSList *d;
int ret;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return SRD_ERR_ARG;
}
for (d = sess->di_list; d; d = d->next) {
if ((ret = srd_inst_decode(d->data, start_samplenum,
end_samplenum, inbuf, inbuflen, unitsize)) != SRD_OK)
return ret;
}
return SRD_OK;
}
/* This function behaves exactly like read(). The only difference is
* that it accepts the gnutls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
uint8_t * data, size_t data_size, void* seq)
{
int ret;
if (type != GNUTLS_ALERT && (data_size == 0 || data == NULL))
{
return GNUTLS_E_INVALID_REQUEST;
}
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
_dtls_async_timer_check(session);
/* If we have enough data in the cache do not bother receiving
* a new packet. (in order to flush the cache)
*/
ret = check_buffers (session, type, data, data_size, seq);
if (ret != 0)
return ret;
ret = _gnutls_recv_in_buffers(session, type, htype);
if (ret < 0 && ret != GNUTLS_E_SESSION_EOF)
return gnutls_assert_val(ret);
return check_buffers (session, type, data, data_size, seq);
}
/** @private */
SRD_PRIV struct srd_pd_callback *srd_pd_output_callback_find(
struct srd_session *sess, int output_type)
{
GSList *l;
struct srd_pd_callback *tmp, *pd_cb;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return NULL;
}
pd_cb = NULL;
for (l = sess->callbacks; l; l = l->next) {
tmp = l->data;
if (tmp->output_type == output_type) {
pd_cb = tmp;
break;
}
}
return pd_cb;
}
/** @private */
SRD_PRIV void srd_inst_free_all(struct srd_session *sess, GSList *stack)
{
GSList *l;
struct srd_decoder_inst *di;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return;
}
di = NULL;
for (l = stack ? stack : sess->di_list; di == NULL && l != NULL; l = l->next) {
di = l->data;
if (di->next_di)
srd_inst_free_all(sess, di->next_di);
srd_inst_free(di);
}
if (!stack) {
g_slist_free(sess->di_list);
sess->di_list = NULL;
}
}
/**
* Find a decoder instance by its instance ID.
*
* Only the bottom level of instances are searched -- instances already stacked
* on top of another one will not be found.
*
* @param sess The session holding the protocol decoder instance.
* @param inst_id The instance ID to be found.
*
* @return Pointer to struct srd_decoder_inst, or NULL if not found.
*
* @since 0.3.0
*/
SRD_API struct srd_decoder_inst *srd_inst_find_by_id(struct srd_session *sess,
const char *inst_id)
{
GSList *l;
struct srd_decoder_inst *tmp, *di;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return NULL;
}
di = NULL;
for (l = sess->di_list; l; l = l->next) {
tmp = l->data;
if (!strcmp(tmp->inst_id, inst_id)) {
di = tmp;
break;
}
}
return di;
}
/**
* Start a decoding session.
*
* Decoders, instances and stack must have been prepared beforehand,
* and all SRD_CONF parameters set.
*
* @param sess The session to start.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.3.0
*/
SRD_API int srd_session_start(struct srd_session *sess)
{
GSList *d;
struct srd_decoder_inst *di;
int ret;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session pointer.");
return SRD_ERR;
}
srd_dbg("Calling start() on all instances in session %d.", sess->session_id);
/* Run the start() method on all decoders receiving frontend data. */
ret = SRD_OK;
for (d = sess->di_list; d; d = d->next) {
di = d->data;
if ((ret = srd_inst_start(di)) != SRD_OK)
break;
}
return ret;
}
static struct srd_decoder_inst *srd_sess_inst_find_by_obj(
struct srd_session *sess, const GSList *stack,
const PyObject *obj)
{
const GSList *l;
struct srd_decoder_inst *tmp, *di;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return NULL;
}
di = NULL;
for (l = stack ? stack : sess->di_list; di == NULL && l != NULL; l = l->next) {
tmp = l->data;
if (tmp->py_inst == obj)
di = tmp;
else if (tmp->next_di)
di = srd_sess_inst_find_by_obj(sess, tmp->next_di, obj);
}
return di;
}
/**
* Send a chunk of logic sample data to a running decoder session.
*
* If no channel map has been set up, the logic samples must be arranged
* in channel order, in the least amount of space possible. The default
* channel set consists of all required channels + all optional channels.
*
* The size of a sample in inbuf is the unit size passed to
* srd_inst_channel_set_all(). If no channel map has been configured, it is
* the minimum number of bytes needed to store the default channels.
*
* @param sess The session to use.
* @param start_samplenum The sample number of the first sample in this chunk.
* @param end_samplenum The sample number of the last sample in this chunk.
* @param inbuf Pointer to sample data.
* @param inbuflen Length in bytes of the buffer.
*
* @return SRD_OK upon success, a (negative) error code otherwise.
*
* @since 0.3.0
*/
SRD_API int srd_session_send(struct srd_session *sess,
uint64_t start_samplenum, uint64_t end_samplenum,
const uint8_t *inbuf, uint64_t inbuflen)
{
GSList *d;
int ret;
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return SRD_ERR_ARG;
}
srd_dbg("Calling decode() on all instances with starting sample "
"number %" PRIu64 ", %" PRIu64 " bytes at 0x%p",
start_samplenum, inbuflen, inbuf);
for (d = sess->di_list; d; d = d->next) {
if ((ret = srd_inst_decode(d->data, start_samplenum,
end_samplenum, inbuf, inbuflen)) != SRD_OK)
return ret;
}
return SRD_OK;
}
/* This function behaves exactly like write(). The only difference is
* that it accepts, the gnutls_session_t and the content_type_t of data to
* send (if called by the user the Content is specific)
* It is intended to transfer data, under the current session.
*
* Oct 30 2001: Removed capability to send data more than MAX_RECORD_SIZE.
* This makes the function much easier to read, and more error resistant
* (there were cases were the old function could mess everything up).
* --nmav
*
* This function may accept a NULL pointer for data, and 0 for size, if
* and only if the previous send was interrupted for some reason.
*
*/
ssize_t
_gnutls_send_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype, const void *_data,
size_t sizeofdata)
{
uint8_t *cipher;
int cipher_size;
int retval, ret;
int data2send_size;
uint8_t headers[5];
const uint8_t *data = _data;
int erecord_size = 0;
opaque *erecord = NULL;
/* Do not allow null pointer if the send buffer is empty.
* If the previous send was interrupted then a null pointer is
* ok, and means to resume.
*/
if (session->internals.record_send_buffer.length == 0 &&
(sizeofdata == 0 && _data == NULL))
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
if (type != GNUTLS_ALERT) /* alert messages are sent anyway */
if (session_is_valid (session) || session->internals.may_not_write != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
headers[0] = type;
/* Use the default record version, if it is
* set.
*/
copy_record_version (session, htype, &headers[1]);
_gnutls_record_log
("REC[%x]: Sending Packet[%d] %s(%d) with length: %d\n", session,
(int) _gnutls_uint64touint32 (&session->connection_state.
write_sequence_number),
_gnutls_packet2str (type), type, sizeofdata);
if (sizeofdata > MAX_RECORD_SEND_SIZE)
data2send_size = MAX_RECORD_SEND_SIZE;
else
data2send_size = sizeofdata;
/* Only encrypt if we don't have data to send
* from the previous run. - probably interrupted.
*/
if (session->internals.record_send_buffer.length > 0)
{
ret = _gnutls_io_write_flush (session);
if (ret > 0)
cipher_size = ret;
else
cipher_size = 0;
cipher = NULL;
retval = session->internals.record_send_buffer_user_size;
}
else
{
/* now proceed to packet encryption
*/
cipher_size = data2send_size + MAX_RECORD_OVERHEAD;
cipher = gnutls_malloc (cipher_size);
if (cipher == NULL)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
cipher_size =
_gnutls_encrypt (session, headers, RECORD_HEADER_SIZE, data,
data2send_size, cipher, cipher_size, type, 1);
if (cipher_size <= 0)
{
gnutls_assert ();
if (cipher_size == 0)
cipher_size = GNUTLS_E_ENCRYPTION_FAILED;
gnutls_afree (erecord);
gnutls_free (cipher);
return cipher_size; /* error */
}
retval = data2send_size;
session->internals.record_send_buffer_user_size = data2send_size;
/* increase sequence number
*/
if (_gnutls_uint64pp
(&session->connection_state.write_sequence_number) != 0)
{
session_invalidate (session);
gnutls_assert ();
gnutls_afree (erecord);
gnutls_free (cipher);
return GNUTLS_E_RECORD_LIMIT_REACHED;
}
ret =
_gnutls_io_write_buffered2 (session, erecord, erecord_size,
cipher, cipher_size);
gnutls_afree (erecord);
gnutls_free (cipher);
}
if (ret != cipher_size + erecord_size)
{
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
{
/* If we have sent any data then just return
* the error value. Do not invalidate the session.
*/
gnutls_assert ();
return ret;
}
if (ret > 0)
{
gnutls_assert ();
ret = GNUTLS_E_INTERNAL_ERROR;
}
session_unresumable (session);
session->internals.may_not_write = 1;
gnutls_assert ();
return ret;
}
session->internals.record_send_buffer_user_size = 0;
_gnutls_record_log ("REC[%x]: Sent Packet[%d] %s(%d) with length: %d\n",
session,
(int) _gnutls_uint64touint32 (&session->
connection_state.
write_sequence_number),
_gnutls_packet2str (type), type, cipher_size);
return retval;
}
/**
* Create a new protocol decoder instance.
*
* @param sess The session holding the protocol decoder instance.
* @param decoder_id Decoder 'id' field.
* @param options GHashtable of options which override the defaults set in
* the decoder class. May be NULL.
*
* @return Pointer to a newly allocated struct srd_decoder_inst, or
* NULL in case of failure.
*
* @since 0.3.0
*/
SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
const char *decoder_id, GHashTable *options)
{
int i;
struct srd_decoder *dec;
struct srd_decoder_inst *di;
char *inst_id;
i = 1;
srd_dbg("Creating new %s instance.", decoder_id);
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return NULL;
}
if (!(dec = srd_decoder_get_by_id(decoder_id))) {
srd_err("Protocol decoder %s not found.", decoder_id);
return NULL;
}
di = g_malloc0(sizeof(struct srd_decoder_inst));
di->decoder = dec;
di->sess = sess;
if (options) {
inst_id = g_hash_table_lookup(options, "id");
if (inst_id)
di->inst_id = g_strdup(inst_id);
g_hash_table_remove(options, "id");
}
/* Create a unique instance ID (as none was provided). */
if (!di->inst_id) {
di->inst_id = g_strdup_printf("%s-%d", decoder_id, i++);
while (srd_inst_find_by_id(sess, di->inst_id)) {
g_free(di->inst_id);
di->inst_id = g_strdup_printf("%s-%d", decoder_id, i++);
}
}
/*
* Prepare a default channel map, where samples come in the
* order in which the decoder class defined them.
*/
di->dec_num_channels = g_slist_length(di->decoder->channels) +
g_slist_length(di->decoder->opt_channels);
if (di->dec_num_channels) {
di->dec_channelmap =
g_malloc(sizeof(int) * di->dec_num_channels);
for (i = 0; i < di->dec_num_channels; i++)
di->dec_channelmap[i] = i;
/*
* Will be used to prepare a sample at every iteration
* of the instance's decode() method.
*/
di->channel_samples = g_malloc(di->dec_num_channels);
}
/* Create a new instance of this decoder class. */
if (!(di->py_inst = PyObject_CallObject(dec->py_dec, NULL))) {
if (PyErr_Occurred())
srd_exception_catch("Failed to create %s instance",
decoder_id);
g_free(di->dec_channelmap);
g_free(di);
return NULL;
}
if (options && srd_inst_option_set(di, options) != SRD_OK) {
g_free(di->dec_channelmap);
g_free(di);
return NULL;
}
di->condition_list = NULL;
di->match_array = NULL;
di->abs_start_samplenum = 0;
di->abs_end_samplenum = 0;
di->inbuf = NULL;
di->inbuflen = 0;
di->abs_cur_samplenum = 0;
di->old_pins_array = NULL;
di->thread_handle = NULL;
di->got_new_samples = FALSE;
di->handled_all_samples = FALSE;
/* Instance takes input from a frontend by default. */
sess->di_list = g_slist_append(sess->di_list, di);
srd_dbg("Created new %s instance with ID %s.", decoder_id, di->inst_id);
return di;
}
/* This function behaves exactly like write(). The only difference is
* that it accepts, the gnutls_session_t and the content_type_t of data to
* send (if called by the user the Content is specific)
* It is intended to transfer data, under the current session.
*
* Oct 30 2001: Removed capability to send data more than MAX_RECORD_SIZE.
* This makes the function much easier to read, and more error resistant
* (there were cases were the old function could mess everything up).
* --nmav
*
* This function may accept a NULL pointer for data, and 0 for size, if
* and only if the previous send was interrupted for some reason.
*
*/
ssize_t
_gnutls_send_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
unsigned int epoch_rel, const void *_data,
size_t sizeofdata, unsigned int mflags)
{
mbuffer_st *bufel;
ssize_t cipher_size;
int retval, ret;
int data2send_size;
uint8_t headers[5];
const uint8_t *data = _data;
record_parameters_st *record_params;
record_state_st *record_state;
ret = _gnutls_epoch_get (session, epoch_rel, &record_params);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* Safeguard against processing data with an incomplete cipher state. */
if (!record_params->initialized)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
record_state = &record_params->write;
/* Do not allow null pointer if the send buffer is empty.
* If the previous send was interrupted then a null pointer is
* ok, and means to resume.
*/
if (session->internals.record_send_buffer.byte_length == 0 &&
(sizeofdata == 0 && _data == NULL))
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
if (type != GNUTLS_ALERT) /* alert messages are sent anyway */
if (session_is_valid (session) || session->internals.may_not_write != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
headers[0] = type;
/* Use the default record version, if it is
* set.
*/
copy_record_version (session, htype, &headers[1]);
_gnutls_record_log
("REC[%p]: Sending Packet[%d] %s(%d) with length: %d\n", session,
(int) _gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (type), type, (int) sizeofdata);
if (sizeofdata > MAX_RECORD_SEND_SIZE)
data2send_size = MAX_RECORD_SEND_SIZE;
else
data2send_size = sizeofdata;
/* Only encrypt if we don't have data to send
* from the previous run. - probably interrupted.
*/
if (mflags != 0 && session->internals.record_send_buffer.byte_length > 0)
{
ret = _gnutls_io_write_flush (session);
if (ret > 0)
cipher_size = ret;
else
cipher_size = 0;
retval = session->internals.record_send_buffer_user_size;
}
else
{
/* now proceed to packet encryption
*/
cipher_size = data2send_size + MAX_RECORD_OVERHEAD;
bufel = _mbuffer_alloc (cipher_size, cipher_size);
if (bufel == NULL)
{
gnutls_assert ();
return GNUTLS_E_MEMORY_ERROR;
}
cipher_size =
_gnutls_encrypt (session, headers, RECORD_HEADER_SIZE, data,
data2send_size, _mbuffer_get_udata_ptr (bufel),
cipher_size, type,
(session->internals.priorities.no_padding ==
0) ? 1 : 0, record_params);
if (cipher_size <= 0)
{
gnutls_assert ();
if (cipher_size == 0)
cipher_size = GNUTLS_E_ENCRYPTION_FAILED;
gnutls_free (bufel);
return cipher_size; /* error */
}
retval = data2send_size;
session->internals.record_send_buffer_user_size = data2send_size;
/* increase sequence number
*/
if (_gnutls_uint64pp (&record_state->sequence_number) != 0)
{
session_invalidate (session);
gnutls_assert ();
gnutls_free (bufel);
return GNUTLS_E_RECORD_LIMIT_REACHED;
}
_mbuffer_set_udata_size (bufel, cipher_size);
ret = _gnutls_io_write_buffered (session, bufel, mflags);
}
if (ret != cipher_size)
{
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
{
/* If we have sent any data then just return
* the error value. Do not invalidate the session.
*/
gnutls_assert ();
return ret;
}
if (ret > 0)
{
gnutls_assert ();
ret = GNUTLS_E_INTERNAL_ERROR;
}
session_unresumable (session);
session->internals.may_not_write = 1;
gnutls_assert ();
return ret;
}
session->internals.record_send_buffer_user_size = 0;
_gnutls_record_log ("REC[%p]: Sent Packet[%d] %s(%d) with length: %d\n",
session,
(int)
_gnutls_uint64touint32
(&record_state->sequence_number),
_gnutls_packet2str (type), type, (int) cipher_size);
return retval;
}
/* This function behaves exactly like write(). The only difference is
* that it accepts, the gnutls_session_t and the content_type_t of data to
* send (if called by the user the Content is specific)
* It is intended to transfer data, under the current session.
*
* @type: The content type to send
* @htype: If this is a handshake message then the handshake type
* @epoch_rel: %EPOCH_READ_* or %EPOCH_WRITE_*
* @data: the data to be sent
* @data_size: the size of the @data
* @target_length: @data_size + minimum required padding
* @mflags: zero or %MBUFFER_FLUSH
*
* Oct 30 2001: Removed capability to send data more than MAX_RECORD_SIZE.
* This makes the function much easier to read, and more error resistant
* (there were cases were the old function could mess everything up).
* --nmav
*
* This function may accept a NULL pointer for data, and 0 for size, if
* and only if the previous send was interrupted for some reason.
*
*/
ssize_t
_gnutls_send_tlen_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
unsigned int epoch_rel, const void *_data,
size_t data_size, size_t target_length, unsigned int mflags)
{
mbuffer_st *bufel;
ssize_t cipher_size;
int retval, ret;
int send_data_size;
uint8_t *headers;
int header_size;
const uint8_t *data = _data;
record_parameters_st *record_params;
record_state_st *record_state;
ret = _gnutls_epoch_get (session, epoch_rel, &record_params);
if (ret < 0)
return gnutls_assert_val(ret);
/* Safeguard against processing data with an incomplete cipher state. */
if (!record_params->initialized)
return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
record_state = &record_params->write;
/* Do not allow null pointer if the send buffer is empty.
* If the previous send was interrupted then a null pointer is
* ok, and means to resume.
*/
if (session->internals.record_send_buffer.byte_length == 0 &&
(data_size == 0 && _data == NULL))
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
if (type != GNUTLS_ALERT) /* alert messages are sent anyway */
if (session_is_valid (session) || session->internals.may_not_write != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
if (data_size > MAX_USER_SEND_SIZE(session))
{
if (IS_DTLS(session))
return gnutls_assert_val(GNUTLS_E_LARGE_PACKET);
send_data_size = MAX_USER_SEND_SIZE(session);
}
else
send_data_size = data_size;
/* Only encrypt if we don't have data to send
* from the previous run. - probably interrupted.
*/
if (mflags != 0 && session->internals.record_send_buffer.byte_length > 0)
{
ret = _gnutls_io_write_flush (session);
if (ret > 0)
cipher_size = ret;
else
cipher_size = 0;
retval = session->internals.record_send_buffer_user_size;
}
else
{
if (unlikely((send_data_size == 0 && target_length == 0)))
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
/* now proceed to packet encryption
*/
cipher_size = MAX_RECORD_SEND_SIZE(session);
bufel = _mbuffer_alloc (0, cipher_size+CIPHER_SLACK_SIZE);
if (bufel == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
headers = _mbuffer_get_uhead_ptr(bufel);
headers[0] = type;
/* Use the default record version, if it is
* set. */
copy_record_version (session, htype, &headers[1]);
header_size = RECORD_HEADER_SIZE(session);
/* Adjust header length and add sequence for DTLS */
if (IS_DTLS(session))
memcpy(&headers[3], &record_state->sequence_number.i, 8);
_gnutls_record_log
("REC[%p]: Preparing Packet %s(%d) with length: %d and target length: %d\n", session,
_gnutls_packet2str (type), type, (int) data_size, (int) target_length);
_mbuffer_set_udata_size(bufel, cipher_size);
_mbuffer_set_uhead_size(bufel, header_size);
ret =
_gnutls_encrypt (session,
data, send_data_size, target_length,
bufel, type, record_params);
if (ret <= 0)
{
gnutls_assert ();
if (ret == 0)
ret = GNUTLS_E_ENCRYPTION_FAILED;
gnutls_free (bufel);
return ret; /* error */
}
cipher_size = _mbuffer_get_udata_size(bufel);
retval = send_data_size;
session->internals.record_send_buffer_user_size = send_data_size;
/* increase sequence number
*/
if (sequence_increment (session, &record_state->sequence_number) != 0)
{
session_invalidate (session);
gnutls_free (bufel);
return gnutls_assert_val(GNUTLS_E_RECORD_LIMIT_REACHED);
}
ret = _gnutls_io_write_buffered (session, bufel, mflags);
}
if (ret != cipher_size)
{
/* If we have sent any data then just return
* the error value. Do not invalidate the session.
*/
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
return gnutls_assert_val(ret);
if (ret > 0)
ret = gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
session_unresumable (session);
session->internals.may_not_write = 1;
return gnutls_assert_val(ret);
}
session->internals.record_send_buffer_user_size = 0;
_gnutls_record_log ("REC[%p]: Sent Packet[%d] %s(%d) in epoch %d and length: %d\n",
session,
(unsigned int)
_gnutls_uint64touint32
(&record_state->sequence_number),
_gnutls_packet2str (type), type,
(int) record_params->epoch,
(int) cipher_size);
return retval;
}
/* This function behaves exactly like read(). The only difference is
* that it accepts the gnutls_session_t and the content_type_t of data to
* receive (if called by the user the Content is Userdata only)
* It is intended to receive data, under the current session.
*
* The gnutls_handshake_description_t was introduced to support SSL V2.0 client hellos.
*/
ssize_t
_gnutls_recv_int (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype,
opaque * data, size_t sizeofdata)
{
int decrypted_length;
opaque version[2];
content_type_t recv_type;
uint16_t length;
uint8_t *ciphertext;
int ret, ret2;
uint16_t header_size;
int empty_packet = 0;
gnutls_datum_t data_enc, tmp;
record_parameters_st *record_params;
record_state_st *record_state;
ret = _gnutls_epoch_get (session, EPOCH_READ_CURRENT, &record_params);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* Safeguard against processing data with an incomplete cipher state. */
if (!record_params->initialized)
{
gnutls_assert ();
return GNUTLS_E_INVALID_REQUEST;
}
record_state = &record_params->read;
if (type != GNUTLS_ALERT && (sizeofdata == 0 || data == NULL))
{
return GNUTLS_E_INVALID_REQUEST;
}
begin:
if (empty_packet > MAX_EMPTY_PACKETS_SEQUENCE)
{
gnutls_assert ();
return GNUTLS_E_TOO_MANY_EMPTY_PACKETS;
}
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
{
gnutls_assert ();
return GNUTLS_E_INVALID_SESSION;
}
/* If we have enough data in the cache do not bother receiving
* a new packet. (in order to flush the cache)
*/
ret = check_buffers (session, type, data, sizeofdata);
if (ret != 0)
return ret;
/* default headers for TLS 1.0
*/
header_size = RECORD_HEADER_SIZE;
if ((ret =
_gnutls_io_read_buffered (session, header_size, -1)) != header_size)
{
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
return ret;
session_invalidate (session);
if (type == GNUTLS_ALERT)
{
gnutls_assert ();
return 0; /* we were expecting close notify */
}
session_unresumable (session);
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
ret = _mbuffer_linearize (&session->internals.record_recv_buffer);
if (ret != 0)
{
gnutls_assert ();
return ret;
}
_mbuffer_get_first (&session->internals.record_recv_buffer, &data_enc);
if ((ret =
record_check_headers (session, data_enc.data, type, htype, &recv_type,
version, &length, &header_size)) < 0)
{
gnutls_assert ();
return ret;
}
/* Here we check if the Type of the received packet is
* ok.
*/
if ((ret = check_recv_type (recv_type)) < 0)
{
gnutls_assert ();
return ret;
}
/* Here we check if the advertized version is the one we
* negotiated in the handshake.
*/
if ((ret = record_check_version (session, htype, version)) < 0)
{
gnutls_assert ();
session_invalidate (session);
return ret;
}
_gnutls_record_log
("REC[%p]: Expected Packet[%d] %s(%d) with length: %d\n", session,
(int) _gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (type), type, (int) sizeofdata);
_gnutls_record_log ("REC[%p]: Received Packet[%d] %s(%d) with length: %d\n",
session,
(int)
_gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (recv_type), recv_type, length);
if (length > MAX_RECV_SIZE)
{
_gnutls_record_log
("REC[%p]: FATAL ERROR: Received packet with length: %d\n",
session, length);
session_unresumable (session);
session_invalidate (session);
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
/* check if we have that data into buffer.
*/
if ((ret =
_gnutls_io_read_buffered (session, header_size + length,
recv_type)) != header_size + length)
{
if (ret < 0 && gnutls_error_is_fatal (ret) == 0)
return ret;
session_unresumable (session);
session_invalidate (session);
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
/* ok now we are sure that we can read all the data - so
* move on !
*/
ret = _mbuffer_linearize (&session->internals.record_recv_buffer);
if (ret != 0)
{
gnutls_assert ();
return ret;
}
_mbuffer_get_first (&session->internals.record_recv_buffer, &data_enc);
ciphertext = &data_enc.data[header_size];
ret = get_temp_recv_buffer (session, &tmp);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* decrypt the data we got.
*/
ret =
_gnutls_decrypt (session, ciphertext, length, tmp.data, tmp.size,
recv_type, record_params);
if (ret < 0)
{
session_unresumable (session);
session_invalidate (session);
gnutls_assert ();
return ret;
}
_mbuffer_remove_bytes (&session->internals.record_recv_buffer,
header_size + length);
decrypted_length = ret;
/* Check if this is a CHANGE_CIPHER_SPEC
*/
if (type == GNUTLS_CHANGE_CIPHER_SPEC &&
recv_type == GNUTLS_CHANGE_CIPHER_SPEC)
{
_gnutls_record_log
("REC[%p]: ChangeCipherSpec Packet was received\n", session);
if ((size_t) ret != sizeofdata)
{ /* sizeofdata should be 1 */
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
}
memcpy (data, tmp.data, sizeofdata);
return ret;
}
_gnutls_record_log
("REC[%p]: Decrypted Packet[%d] %s(%d) with length: %d\n", session,
(int) _gnutls_uint64touint32 (&record_state->sequence_number),
_gnutls_packet2str (recv_type), recv_type, decrypted_length);
/* increase sequence number
*/
if (_gnutls_uint64pp (&record_state->sequence_number) != 0)
{
session_invalidate (session);
gnutls_assert ();
return GNUTLS_E_RECORD_LIMIT_REACHED;
}
ret =
record_check_type (session, recv_type, type, htype, tmp.data,
decrypted_length);
if (ret < 0)
{
if (ret == GNUTLS_E_INT_RET_0)
return 0;
gnutls_assert ();
return ret;
}
/* Get Application data from buffer
*/
if ((recv_type == type) &&
(type == GNUTLS_APPLICATION_DATA ||
type == GNUTLS_HANDSHAKE || type == GNUTLS_INNER_APPLICATION))
{
ret = _gnutls_record_buffer_get (type, session, data, sizeofdata);
if (ret < 0)
{
gnutls_assert ();
return ret;
}
/* if the buffer just got empty
*/
if (_gnutls_record_buffer_get_size (type, session) == 0)
{
if ((ret2 = _gnutls_io_clear_peeked_data (session)) < 0)
{
gnutls_assert ();
return ret2;
}
}
}
else
{
gnutls_assert ();
return GNUTLS_E_UNEXPECTED_PACKET;
/* we didn't get what we wanted to
*/
}
/* (originally for) TLS 1.0 CBC protection.
* Actually this code is called if we just received
* an empty packet. An empty TLS packet is usually
* sent to protect some vulnerabilities in the CBC mode.
* In that case we go to the beginning and start reading
* the next packet.
*/
if (ret == 0)
{
empty_packet++;
goto begin;
}
return ret;
}
/* @ms: is the number of milliseconds to wait for data. Use zero for indefinite.
*
* This will receive record layer packets and add them to
* application_data_buffer and handshake_data_buffer.
*
* If the htype is not -1 then handshake timeouts
* will be enforced.
*/
ssize_t
_gnutls_recv_in_buffers (gnutls_session_t session, content_type_t type,
gnutls_handshake_description_t htype, unsigned int ms)
{
uint64 *packet_sequence;
gnutls_datum_t ciphertext;
mbuffer_st* bufel = NULL, *decrypted = NULL;
gnutls_datum_t t;
int ret;
unsigned int empty_fragments = 0;
record_parameters_st *record_params;
record_state_st *record_state;
struct tls_record_st record;
begin:
if (empty_fragments > session->internals.priorities.max_empty_records)
{
gnutls_assert ();
return GNUTLS_E_TOO_MANY_EMPTY_PACKETS;
}
if (session->internals.read_eof != 0)
{
/* if we have already read an EOF
*/
return 0;
}
else if (session_is_valid (session) != 0
|| session->internals.may_not_read != 0)
return gnutls_assert_val(GNUTLS_E_INVALID_SESSION);
/* get the record state parameters */
ret = _gnutls_epoch_get (session, EPOCH_READ_CURRENT, &record_params);
if (ret < 0)
return gnutls_assert_val (ret);
/* Safeguard against processing data with an incomplete cipher state. */
if (!record_params->initialized)
return gnutls_assert_val (GNUTLS_E_INTERNAL_ERROR);
record_state = &record_params->read;
/* receive headers */
ret = recv_headers(session, type, htype, &record, &ms);
if (ret < 0)
{
ret = gnutls_assert_val_fatal(ret);
goto recv_error;
}
if (IS_DTLS(session))
packet_sequence = &record.sequence;
else
packet_sequence = &record_state->sequence_number;
/* Read the packet data and insert it to record_recv_buffer.
*/
ret =
_gnutls_io_read_buffered (session, record.packet_size,
record.type, &ms);
if (ret != record.packet_size)
{
gnutls_assert();
goto recv_error;
}
/* ok now we are sure that we have read all the data - so
* move on !
*/
ret = _mbuffer_linearize (&session->internals.record_recv_buffer);
if (ret < 0)
return gnutls_assert_val(ret);
bufel = _mbuffer_head_get_first (&session->internals.record_recv_buffer, NULL);
if (bufel == NULL)
return gnutls_assert_val(GNUTLS_E_INTERNAL_ERROR);
/* We allocate the maximum possible to allow few compressed bytes to expand to a
* full record.
*/
decrypted = _mbuffer_alloc(record.length, record.length);
if (decrypted == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
ciphertext.data = (uint8_t*)_mbuffer_get_udata_ptr(bufel) + record.header_size;
ciphertext.size = record.length;
/* decrypt the data we got.
*/
t.data = _mbuffer_get_udata_ptr(decrypted);
t.size = _mbuffer_get_udata_size(decrypted);
ret =
_gnutls_decrypt (session, &ciphertext, &t,
record.type, record_params, packet_sequence);
if (ret >= 0) _mbuffer_set_udata_size(decrypted, ret);
_mbuffer_head_remove_bytes (&session->internals.record_recv_buffer,
record.header_size + record.length);
if (ret < 0)
{
gnutls_assert();
_gnutls_audit_log(session, "Discarded message[%u] due to invalid decryption\n",
(unsigned int)_gnutls_uint64touint32 (packet_sequence));
goto sanity_check_error;
}
/* check for duplicates. We check after the message
* is processed and authenticated to avoid someone
* messing with our windows.
*/
if (IS_DTLS(session) && session->internals.no_replay_protection == 0)
{
ret = _dtls_record_check(record_params, packet_sequence);
if (ret < 0)
{
_gnutls_audit_log(session, "Discarded duplicate message[%u.%u]: %s\n",
(unsigned int)record.sequence.i[0]*256 +(unsigned int)record.sequence.i[1],
(unsigned int) _gnutls_uint64touint32 (packet_sequence), _gnutls_packet2str (record.type));
goto sanity_check_error;
}
_gnutls_record_log
("REC[%p]: Decrypted Packet[%u.%u] %s(%d) with length: %d\n", session,
(unsigned int)record.sequence.i[0]*256 +(unsigned int)record.sequence.i[1],
(unsigned int) _gnutls_uint64touint32 (packet_sequence),
_gnutls_packet2str (record.type), record.type, (int)_mbuffer_get_udata_size(decrypted));
}
else
{
_gnutls_record_log
("REC[%p]: Decrypted Packet[%u] %s(%d) with length: %d\n", session,
(unsigned int) _gnutls_uint64touint32 (packet_sequence),
_gnutls_packet2str (record.type), record.type, (int)_mbuffer_get_udata_size(decrypted));
}
/* increase sequence number
*/
if (!IS_DTLS(session) && sequence_increment (session, &record_state->sequence_number) != 0)
{
session_invalidate (session);
gnutls_assert ();
ret = GNUTLS_E_RECORD_LIMIT_REACHED;
goto sanity_check_error;
}
/* (originally for) TLS 1.0 CBC protection.
* Actually this code is called if we just received
* an empty packet. An empty TLS packet is usually
* sent to protect some vulnerabilities in the CBC mode.
* In that case we go to the beginning and start reading
* the next packet.
*/
if (_mbuffer_get_udata_size(decrypted) == 0)
{
_mbuffer_xfree(&decrypted);
empty_fragments++;
goto begin;
}
if (record.v2)
decrypted->htype = GNUTLS_HANDSHAKE_CLIENT_HELLO_V2;
else
{
uint8_t * p = _mbuffer_get_udata_ptr(decrypted);
decrypted->htype = p[0];
}
ret =
record_add_to_buffers (session, &record, type, htype,
packet_sequence, decrypted);
/* bufel is now either deinitialized or buffered somewhere else */
if (ret < 0)
return gnutls_assert_val(ret);
return ret;
discard:
session->internals.dtls.packets_dropped++;
/* discard the whole received fragment. */
bufel = _mbuffer_head_pop_first(&session->internals.record_recv_buffer);
_mbuffer_xfree(&bufel);
return gnutls_assert_val(GNUTLS_E_AGAIN);
sanity_check_error:
if (IS_DTLS(session))
{
session->internals.dtls.packets_dropped++;
ret = gnutls_assert_val(GNUTLS_E_AGAIN);
goto cleanup;
}
session_unresumable (session);
session_invalidate (session);
cleanup:
_mbuffer_xfree(&decrypted);
return ret;
recv_error:
if (ret < 0 && (gnutls_error_is_fatal (ret) == 0 || ret == GNUTLS_E_TIMEDOUT))
return ret;
if (type == GNUTLS_ALERT) /* we were expecting close notify */
{
session_invalidate (session);
gnutls_assert ();
return 0;
}
if (IS_DTLS(session))
{
goto discard;
}
session_invalidate (session);
session_unresumable (session);
if (ret == 0)
return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
else
return ret;
}
int cmd_login(int argc, char **argv)
{
static struct option long_options[] = {
{"trust", no_argument, NULL, 't'},
{"plaintext-key", no_argument, NULL, 'P'},
{"force", no_argument, NULL, 'f'},
{"color", required_argument, NULL, 'C'},
{0, 0, 0, 0}
};
int option;
int option_index;
bool trust = false;
bool plaintext_key = false;
bool force = false;
char *username;
_cleanup_free_ char *error = NULL;
_cleanup_free_ char *password = NULL;
int iterations;
struct session *session;
unsigned char key[KDF_HASH_LEN];
char hex[KDF_HEX_LEN];
while ((option = getopt_long(argc, argv, "f", long_options, &option_index)) != -1) {
switch (option) {
case 't':
trust = true;
break;
case 'P':
plaintext_key = true;
break;
case 'f':
force = true;
break;
case 'C':
terminal_set_color_mode(
parse_color_mode_string(optarg));
break;
case '?':
default:
die_usage(cmd_login_usage);
}
}
if (argc - optind != 1)
die_usage(cmd_login_usage);
if (!force && plaintext_key && !ask_yes_no(false, "You have used the --plaintext-key option. This option will greatly reduce the security of your passwords. You are advised, instead, to use the agent, whose timeout can be disabled by settting LPASS_AGENT_TIMEOUT=0. Are you sure you would like to do this?"))
die("Login aborted. Try again without --plaintext-key.");
username = argv[optind];
iterations = lastpass_iterations(username);
if (!iterations)
die("Unable to fetch iteration count. Check your internet connection and be sure your username is valid.");
do {
free(password);
password = password_prompt("Master Password", error, "Please enter the LastPass master password for <%s>.", username);
if (!password)
die("Failed to enter correct password.");
kdf_login_key(username, password, iterations, hex);
kdf_decryption_key(username, password, iterations, key);
free(error);
error = NULL;
session = lastpass_login(username, hex, key, iterations, &error, trust);
} while (!session_is_valid(session));
config_unlink("plaintext_key");
if (plaintext_key)
config_write_buffer("plaintext_key", (char *)key, KDF_HASH_LEN);
agent_save(username, iterations, key);
session_save(session, key);
session_free(session);
session = NULL;
terminal_printf(TERMINAL_FG_GREEN TERMINAL_BOLD "Success" TERMINAL_RESET ": Logged in as " TERMINAL_UNDERLINE "%s" TERMINAL_RESET ".\n", username);
return 0;
}
/**
* Create a new protocol decoder instance.
*
* @param sess The session holding the protocol decoder instance.
* @param decoder_id Decoder 'id' field.
* @param options GHashtable of options which override the defaults set in
* the decoder class. May be NULL.
*
* @return Pointer to a newly allocated struct srd_decoder_inst, or
* NULL in case of failure.
*
* @since 0.3.0
*/
SRD_API struct srd_decoder_inst *srd_inst_new(struct srd_session *sess,
const char *decoder_id, GHashTable *options)
{
int i;
struct srd_decoder *dec;
struct srd_decoder_inst *di;
char *inst_id;
srd_dbg("Creating new %s instance.", decoder_id);
if (session_is_valid(sess) != SRD_OK) {
srd_err("Invalid session.");
return NULL;
}
if (!(dec = srd_decoder_get_by_id(decoder_id))) {
srd_err("Protocol decoder %s not found.", decoder_id);
return NULL;
}
if (!(di = g_try_malloc0(sizeof(struct srd_decoder_inst)))) {
srd_err("Failed to g_malloc() instance.");
return NULL;
}
di->decoder = dec;
di->sess = sess;
if (options) {
inst_id = g_hash_table_lookup(options, "id");
di->inst_id = g_strdup(inst_id ? inst_id : decoder_id);
g_hash_table_remove(options, "id");
} else
di->inst_id = g_strdup(decoder_id);
/*
* Prepare a default probe map, where samples come in the
* order in which the decoder class defined them.
*/
di->dec_num_probes = g_slist_length(di->decoder->probes) +
g_slist_length(di->decoder->opt_probes);
if (di->dec_num_probes) {
if (!(di->dec_probemap =
g_try_malloc(sizeof(int) * di->dec_num_probes))) {
srd_err("Failed to g_malloc() probe map.");
g_free(di);
return NULL;
}
for (i = 0; i < di->dec_num_probes; i++)
di->dec_probemap[i] = i;
di->data_unitsize = (di->dec_num_probes + 7) / 8;
/*
* Will be used to prepare a sample at every iteration
* of the instance's decode() method.
*/
if (!(di->probe_samples = g_try_malloc(di->dec_num_probes))) {
srd_err("Failed to g_malloc() sample buffer.");
g_free(di->dec_probemap);
g_free(di);
return NULL;
}
}
/* Create a new instance of this decoder class. */
if (!(di->py_inst = PyObject_CallObject(dec->py_dec, NULL))) {
if (PyErr_Occurred())
srd_exception_catch("failed to create %s instance: ",
decoder_id);
g_free(di->dec_probemap);
g_free(di);
return NULL;
}
if (options && srd_inst_option_set(di, options) != SRD_OK) {
g_free(di->dec_probemap);
g_free(di);
return NULL;
}
/* Instance takes input from a frontend by default. */
sess->di_list = g_slist_append(sess->di_list, di);
return di;
}
