TLVs are really limited in size, so if you want to have truly long data passed
between host and modem, you may end up needing multiple QMI messages where the
long TLV is split in segments. Currently support this by handling a built-in
sequence number expected to be found between the array size prefix and the array
itself (see e.g. TLV 0x13 (PRL) in 'DMS Activate Manual'). This sequence number
can be enabled with the new 'sequence-prefix-format' keyword in the array
definition.
Python 3 doesn't support the replace class method; it's now an instance method only.
string.replace(object, old, new) changes to object.replace(old, new)
sed:
s/string\.replace(\([^,]*\), /\1.replace(/
Try to handle buggy firmware, or just make the library more robust, by
validating the read TLV before really reading it. If a TLV is not considered
valid, we just skip it for now.
E.g.: the "Detailed Service Status" TLV (0x21) in the "NAS Get Serving System"
message is supposed to be a sequence of 5 bytes, but some models (e.g. ZTE MF683)
end up sending only the first 4 bytes.
Some values are sent by the firmware in big endian byte order,
specifically IP addresses, which are sent in network byte order
(ie, big endian). Add the ability to specify the byte order
the firmware handles the value as, and convert that to host
byte order when reading/writing QMI buffers.
We allow passing a GCancellable to every async operation with the clients. Now,
if the cancellable gets cancelled and the operation can be ABORT-ed, then we
do it.
Messages can now be tagged with a special 'abort' keyword, so that whenever the
message times out we issue a new ABORT command to cancel the specific timed out
request.
This support is currently only available for the NAS and WDS services, which are
the ones supporting ABORT for their long-running operations.
Among the tons of fixes done here, we now generate some per-service .sections
file which we then concatenate to build the final libqmi-glib-sections.txt file.
When an array is required to be passed in an input TLV, the user who created it
is responsible for freeing it. Therefore, we should not dump the static array
element clear function in these cases, or these unused methods will end up
breaking the compilation.
Also swapped length and buffer variables; it no longer follows the 'TLV' name
(type,length,value), but it's more consistent with other interfaces where
buffer is given first and then the length.
The contents of the input buffer are never modified when reading variables from
it, so better use a constant pointer in the methods doing it.
What it does change is the pointer to the current position in the constant
buffer.
If we get an error parsing a JSON file we really want to have the exact line
number where the error happened, so don't just skip the comment lines and
substitute them with an empty line instead so that the line numbers don't
change.
For those variables which are containers of other variables (struct, sequence
and array), ensure we call `emit_helper_methods()' in order to generate variable
specific dispose() helpers and such.
This fixes the case of nested arrays of structs (arrays of structs with arrays of
structs whithin).
Use the new 'size-prefix-format' property to specify whether the length prefix
variable is a 'guint8' or a 'guint16'.
We therefore consolidate the way how this length prefix variable is specified in
both arrays and strings.
So, instead of:
"length-prefix-size" : "16"
We now just do:
"size-prefix-format" : "guint16"
The 'array-size' property was used to define an implicit variable to be found at
the beginning of every array. This property expected a dictionary with one
single 'format' key.
Instead of this setup, create a new 'size-prefix-format' property which directly
expects the format string of the variable to be used as array-length indicator.
So, instead of:
"array-size" : { "format" : "guint16" }
We can now just use:
"size-prefix-format" : "guint16"
Also, remove the explicit size definitions when the format is "guint8", as that
is the default already when none specified and the array is not of fixed size.
If 'max-size' is given for an output string variable, we will read up to the
specified number of bytes from the buffer. This will help us handle cases where
the firmware of the device doesn't match what it sends with what it wanted to
send (e.g. IMEI longer than 15 characters).
The service-specific implementation header needs to include only the raw
enums/flags headers; while the source needs to include the enum/flags types
headers.
Aleksander Morgado