+/**
+ * Send a SCPI command, read the reply, parse it as binary data with a
+ * "definite length block" header and store the as an result in scpi_response.
+ *
+ * Callers must free the allocated memory (unless it's NULL) regardless of
+ * the routine's return code. See @ref g_byte_array_free().
+ *
+ * @param[in] scpi Previously initialised SCPI device structure.
+ * @param[in] command The SCPI command to send to the device (can be NULL).
+ * @param[out] scpi_response Pointer where to store the parsed result.
+ *
+ * @return SR_OK upon successfully parsing all values, SR_ERR* upon a parsing
+ * error or upon no response.
+ */
+SR_PRIV int sr_scpi_get_block(struct sr_scpi_dev_inst *scpi,
+ const char *command, GByteArray **scpi_response)
+{
+ int ret;
+ GString* response;
+ gsize oldlen;
+ char buf[10];
+ long llen;
+ long datalen;
+ gint64 timeout;
+
+ *scpi_response = NULL;
+
+ g_mutex_lock(&scpi->scpi_mutex);
+
+ if (command)
+ if (scpi_send(scpi, command) != SR_OK) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ return SR_ERR;
+ }
+
+ if (sr_scpi_read_begin(scpi) != SR_OK) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ return SR_ERR;
+ }
+
+ /*
+ * Assume an initial maximum length, optionally gets adjusted below.
+ * Prepare a NULL return value for when error paths will be taken.
+ */
+ response = g_string_sized_new(1024);
+
+ timeout = g_get_monotonic_time() + scpi->read_timeout_us;
+
+ /* Get (the first chunk of) the response. */
+ do {
+ ret = scpi_read_response(scpi, response, timeout);
+ if (ret < 0) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return ret;
+ }
+ } while (response->len < 2);
+
+ /*
+ * SCPI protocol data blocks are preceeded with a length spec.
+ * The length spec consists of a '#' marker, one digit which
+ * specifies the character count of the length spec, and the
+ * respective number of characters which specify the data block's
+ * length. Raw data bytes follow (thus one must no longer assume
+ * that the received input stream would be an ASCIIZ string).
+ *
+ * Get the data block length, and strip off the length spec from
+ * the input buffer, leaving just the data bytes.
+ */
+ if (response->str[0] != '#') {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return SR_ERR_DATA;
+ }
+ buf[0] = response->str[1];
+ buf[1] = '\0';
+ ret = sr_atol(buf, &llen);
+ /*
+ * The form "#0..." is legal, and does not mean "empty response",
+ * but means that the number of data bytes is not known (or was
+ * not communicated) at this time. Instead the block ends at an
+ * "END MESSAGE" termination sequence. Which translates to active
+ * EOI while a text line termination is sent (CR or LF, and this
+ * text line termination is not part of the block's data value).
+ * Since this kind of #0... response is considered rare, and
+ * depends on specific support in physical transports underneath
+ * the SCPI layer, let's flag the condition and bail out with an
+ * error here, until it's found to be a genuine issue in the field.
+ *
+ * The SCPI 1999.0 specification (see page 220 and following in
+ * the "HCOPy" description) references IEEE 488.2, especially
+ * section 8.7.9 for DEFINITE LENGTH and section 8.7.10 for
+ * INDEFINITE LENGTH ARBITRARY BLOCK RESPONSE DATA. The latter
+ * with a leading "#0" length and a trailing "NL^END" marker.
+ */
+ if (ret == SR_OK && !llen) {
+ sr_err("unsupported INDEFINITE LENGTH ARBITRARY BLOCK RESPONSE");
+ ret = SR_ERR_NA;
+ }
+ if (ret != SR_OK) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return ret;
+ }
+
+ while (response->len < (unsigned long)(2 + llen)) {
+ ret = scpi_read_response(scpi, response, timeout);
+ if (ret < 0) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return ret;
+ }
+ }
+
+ memcpy(buf, &response->str[2], llen);
+ buf[llen] = '\0';
+ ret = sr_atol(buf, &datalen);
+ if ((ret != SR_OK) || (datalen == 0)) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return ret;
+ }
+ g_string_erase(response, 0, 2 + llen);
+
+ /*
+ * Re-allocate the buffer size to the now known length
+ * and keep reading more chunks of response data.
+ */
+ oldlen = response->len;
+ g_string_set_size(response, datalen);
+ g_string_set_size(response, oldlen);
+
+ if (oldlen < (unsigned long)(datalen)) {
+ do {
+ oldlen = response->len;
+ ret = scpi_read_response(scpi, response, timeout);
+
+ /* On timeout truncate the buffer and send the partial response
+ * instead of getting stuck on timeouts...
+ */
+ if (ret == SR_ERR_TIMEOUT) {
+ datalen = oldlen;
+ break;
+ }
+ if (ret < 0) {
+ g_mutex_unlock(&scpi->scpi_mutex);
+ g_string_free(response, TRUE);
+ return ret;
+ }
+ if (ret > 0)
+ timeout = g_get_monotonic_time() + scpi->read_timeout_us;
+ } while (response->len < (unsigned long)(datalen));
+ }
+
+ g_mutex_unlock(&scpi->scpi_mutex);
+
+ /* Convert received data to byte array. */
+ *scpi_response = g_byte_array_new_take(
+ (guint8*)g_string_free(response, FALSE), datalen);
+
+ return SR_OK;
+}
+