summaryrefslogtreecommitdiff
path: root/libqcdm
diff options
context:
space:
mode:
authorDan Williams <dcbw@redhat.com>2012-01-03 00:14:32 -0600
committerDan Williams <dcbw@redhat.com>2012-01-03 00:21:05 -0600
commit7b14063f4676a51c3a0d8b9adc89a9490d6b5814 (patch)
treecf37710ae20a07cf07047d9f52de36a25c23c99b /libqcdm
parent1e1c8a5ae4e5296bd6648feff9390a4692683a1f (diff)
qcdm: remove usage of glib
People have asked for this at various times.
Diffstat (limited to 'libqcdm')
-rw-r--r--libqcdm/configure.ac5
-rw-r--r--libqcdm/src/Makefile.am4
-rw-r--r--libqcdm/src/com.c21
-rw-r--r--libqcdm/src/com.h4
-rw-r--r--libqcdm/src/commands.c838
-rw-r--r--libqcdm/src/commands.h244
-rw-r--r--libqcdm/src/dm-commands.h250
-rw-r--r--libqcdm/src/error.c88
-rw-r--r--libqcdm/src/error.h54
-rw-r--r--libqcdm/src/errors.c60
-rw-r--r--libqcdm/src/errors.h94
-rw-r--r--libqcdm/src/nv-items.h16
-rw-r--r--libqcdm/src/result-private.h35
-rw-r--r--libqcdm/src/result.c438
-rw-r--r--libqcdm/src/result.h26
-rw-r--r--libqcdm/src/utils.c91
-rw-r--r--libqcdm/src/utils.h53
-rw-r--r--libqcdm/tests/test-qcdm-com.c264
-rw-r--r--libqcdm/tests/test-qcdm-escaping.c2
-rw-r--r--libqcdm/tests/test-qcdm-result.c32
-rw-r--r--libqcdm/tests/test-qcdm-result.h1
-rw-r--r--libqcdm/tests/test-qcdm-utils.c4
-rw-r--r--libqcdm/tests/test-qcdm.c1
23 files changed, 1365 insertions, 1260 deletions
diff --git a/libqcdm/configure.ac b/libqcdm/configure.ac
index afd68513..7a6685ae 100644
--- a/libqcdm/configure.ac
+++ b/libqcdm/configure.ac
@@ -23,16 +23,15 @@ AC_PROG_LIBTOOL
dnl Define _GNU_SOURCE for various things like strcasestr()
AC_GNU_SOURCE
-PKG_CHECK_MODULES(MM, glib-2.0 >= 2.18)
-
dnl
dnl Tests
dnl
-AC_ARG_WITH(tests, AS_HELP_STRING([--with-tests], [Build ModemManager tests]))
+AC_ARG_WITH(tests, AS_HELP_STRING([--with-tests], [Build libqcdm tests]))
AM_CONDITIONAL(WITH_TESTS, test "x$with_tests" = "xyes")
case $with_tests in
yes)
with_tests=yes
+ PKG_CHECK_MODULES(MM, glib-2.0 >= 2.18)
;;
*)
with_tests=no
diff --git a/libqcdm/src/Makefile.am b/libqcdm/src/Makefile.am
index f9451c69..6c2de21c 100644
--- a/libqcdm/src/Makefile.am
+++ b/libqcdm/src/Makefile.am
@@ -11,8 +11,8 @@ libqcdm_la_SOURCES = \
com.h \
commands.c \
commands.h \
- error.c \
- error.h \
+ errors.c \
+ errors.h \
result.c \
result.h \
result-private.h \
diff --git a/libqcdm/src/com.c b/libqcdm/src/com.c
index 353103a7..ad50dd0c 100644
--- a/libqcdm/src/com.c
+++ b/libqcdm/src/com.c
@@ -21,21 +21,18 @@
#include <string.h>
#include "com.h"
-#include "error.h"
+#include "errors.h"
-gboolean
-qcdm_port_setup (int fd, GError **error)
+int
+qcdm_port_setup (int fd)
{
struct termios stbuf;
- g_type_init ();
-
errno = 0;
memset (&stbuf, 0, sizeof (stbuf));
if (tcgetattr (fd, &stbuf) != 0) {
- g_set_error (error,
- QCDM_SERIAL_ERROR, QCDM_SERIAL_CONFIG_FAILED,
- "tcgetattr() error: %d", errno);
+ qcdm_err (0, "tcgetattr() error: %d", errno);
+ return -QCDM_ERROR_SERIAL_CONFIG_FAILED;
}
stbuf.c_cflag &= ~(CBAUD | CSIZE | CSTOPB | CLOCAL | PARENB);
@@ -50,12 +47,10 @@ qcdm_port_setup (int fd, GError **error)
errno = 0;
if (tcsetattr (fd, TCSANOW, &stbuf) < 0) {
- g_set_error (error,
- QCDM_SERIAL_ERROR, QCDM_SERIAL_CONFIG_FAILED,
- "tcsetattr() error: %d", errno);
- return FALSE;
+ qcdm_err (0, "tcgetattr() error: %d", errno);
+ return -QCDM_ERROR_SERIAL_CONFIG_FAILED;
}
- return TRUE;
+ return QCDM_SUCCESS;
}
diff --git a/libqcdm/src/com.h b/libqcdm/src/com.h
index 97561d03..7c3e3498 100644
--- a/libqcdm/src/com.h
+++ b/libqcdm/src/com.h
@@ -18,8 +18,8 @@
#ifndef LIBQCDM_COM_H
#define LIBQCDM_COM_H
-#include <glib.h>
+#include "utils.h"
-gboolean qcdm_port_setup (int fd, GError **error);
+int qcdm_port_setup (int fd);
#endif /* LIBQCDM_COM_H */
diff --git a/libqcdm/src/commands.c b/libqcdm/src/commands.c
index 2d4b7077..90134554 100644
--- a/libqcdm/src/commands.c
+++ b/libqcdm/src/commands.c
@@ -16,9 +16,11 @@
*/
#include <string.h>
+#include <stdlib.h>
+#include <endian.h>
#include "commands.h"
-#include "error.h"
+#include "errors.h"
#include "dm-commands.h"
#include "nv-items.h"
#include "result-private.h"
@@ -27,8 +29,8 @@
/**********************************************************************/
-static guint8
-cdma_prev_to_qcdm (guint8 cdma)
+static u_int8_t
+cdma_prev_to_qcdm (u_int8_t cdma)
{
switch (cdma) {
case CDMA_PREV_IS_95:
@@ -51,8 +53,8 @@ cdma_prev_to_qcdm (guint8 cdma)
return QCDM_CDMA_PREV_UNKNOWN;
}
-static guint8
-cdma_band_class_to_qcdm (guint8 cdma)
+static u_int8_t
+cdma_band_class_to_qcdm (u_int8_t cdma)
{
switch (cdma) {
case CDMA_BAND_CLASS_0_CELLULAR_800:
@@ -113,18 +115,21 @@ cdma_band_class_to_qcdm (guint8 cdma)
*
*/
static char *
-bin2hexstr (const guint8 *bytes, int len)
+bin2hexstr (const u_int8_t *bytes, int len)
{
static char hex_digits[] = "0123456789abcdef";
char *result;
int i;
- gsize buflen = (len * 2) + 1;
+ size_t buflen = (len * 2) + 1;
- g_return_val_if_fail (bytes != NULL, NULL);
- g_return_val_if_fail (len > 0, NULL);
- g_return_val_if_fail (len < 4096, NULL); /* Arbitrary limit */
+ qcdm_return_val_if_fail (bytes != NULL, NULL);
+ qcdm_return_val_if_fail (len > 0, NULL);
+ qcdm_return_val_if_fail (len < 4096, NULL); /* Arbitrary limit */
+
+ result = calloc (1, buflen);
+ if (result == NULL)
+ return NULL;
- result = g_malloc0 (buflen);
for (i = 0; i < len; i++) {
result[2*i] = hex_digits[(bytes[i] >> 4) & 0xf];
result[2*i+1] = hex_digits[bytes[i] & 0xf];
@@ -135,88 +140,92 @@ bin2hexstr (const guint8 *bytes, int len)
/**********************************************************************/
-static gboolean
-check_command (const char *buf, gsize len, guint8 cmd, gsize min_len, GError **error)
+static qcdmbool
+check_command (const char *buf, size_t len, u_int8_t cmd, size_t min_len, int *out_error)
{
if (len < 1) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_MALFORMED_RESPONSE,
- "DM command response malformed (must be at least 1 byte in length)");
+ qcdm_err (0, "DM command response malformed (must be at least 1 byte in length)");
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_MALFORMED;
return FALSE;
}
switch (buf[0]) {
case DIAG_CMD_BAD_CMD:
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND,
- "DM command %d unknown or unimplemented by the device",
- cmd);
+ qcdm_err (0, "DM command %d unknown or unimplemented by the device", cmd);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_BAD_COMMAND;
return FALSE;
case DIAG_CMD_BAD_PARM:
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "DM command %d contained invalid parameter",
- cmd);
+ qcdm_err (0, "DM command %d contained invalid parameter", cmd);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_BAD_PARAMETER;
return FALSE;
case DIAG_CMD_BAD_LEN:
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_LENGTH,
- "DM command %d was the wrong size",
- cmd);
+ qcdm_err (0, "DM command %d was the wrong size", cmd);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_BAD_LENGTH;
return FALSE;
case DIAG_CMD_BAD_DEV:
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_NOT_ACCEPTED,
- "DM command %d was not accepted by the device",
- cmd);
+ qcdm_err (0, "DM command %d was not accepted by the device", cmd);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_NOT_ACCEPTED;
return FALSE;
case DIAG_CMD_BAD_MODE:
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_MODE,
- "DM command %d not allowed in the current device mode",
- cmd);
+ qcdm_err (0, "DM command %d not allowed in the current device mode", cmd);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_BAD_MODE;
return FALSE;
case DIAG_CMD_BAD_SPC_MODE:
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_SPC_LOCKED,
- "DM command %d not allowed because the Service Programming Code is locked",
- cmd);
+ qcdm_err (0, "DM command %d not allowed because the Service Programming Code is locked", cmd);
+ if (out_error)
+ *out_error = -QCDM_ERROR_SPC_LOCKED;
return FALSE;
default:
break;
}
if (buf[0] != cmd) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_UNEXPECTED,
- "Unexpected DM command response (expected %d, got %d)",
- cmd, buf[0]);
+ qcdm_err (0, "Unexpected DM command response (expected %d, got %d)", cmd, buf[0]);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_UNEXPECTED;
return FALSE;
}
if (len < min_len) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_LENGTH,
- "DM command %d response not long enough (got %zu, expected "
- "at least %zu).", cmd, len, min_len);
+ qcdm_err (0, "DM command %d response not long enough (got %zu, expected "
+ "at least %zu).", cmd, len, min_len);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_BAD_LENGTH;
return FALSE;
}
return TRUE;
}
-static gboolean
-check_nv_cmd (DMCmdNVReadWrite *cmd, guint16 nv_item, GError **error)
+static qcdmbool
+check_nv_cmd (DMCmdNVReadWrite *cmd, u_int16_t nv_item, int *out_error)
{
- guint16 cmd_item;
+ u_int16_t cmd_item;
- g_return_val_if_fail (cmd != NULL, FALSE);
- g_return_val_if_fail ((cmd->code == DIAG_CMD_NV_READ) || (cmd->code == DIAG_CMD_NV_WRITE), FALSE);
+ qcdm_return_val_if_fail (cmd != NULL, FALSE);
+ qcdm_return_val_if_fail ((cmd->code == DIAG_CMD_NV_READ) || (cmd->code == DIAG_CMD_NV_WRITE), FALSE);
/* NV read/write have a status byte at the end */
if (cmd->status != 0) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_NVCMD_FAILED,
- "The NV operation failed (status 0x%X).",
- GUINT16_FROM_LE (cmd->status));
+ qcdm_err (0, "The NV operation failed (status 0x%X).",
+ le16toh (cmd->status));
+ if (out_error)
+ *out_error = -QCDM_ERROR_NVCMD_FAILED;
return FALSE;
}
- cmd_item = GUINT16_FROM_LE (cmd->nv_item);
+ cmd_item = le16toh (cmd->nv_item);
if (cmd_item != nv_item) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_UNEXPECTED,
- "Unexpected DM NV command response (expected item %d, got "
- "item %d)", nv_item, cmd_item);
+ qcdm_err (0, "Unexpected DM NV command response (expected item %d, got "
+ "item %d)", nv_item, cmd_item);
+ if (out_error)
+ *out_error = -QCDM_ERROR_RESPONSE_UNEXPECTED;
return FALSE;
}
@@ -225,14 +234,14 @@ check_nv_cmd (DMCmdNVReadWrite *cmd, guint16 nv_item, GError **error)
/**********************************************************************/
-gsize
-qcdm_cmd_version_info_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_version_info_new (char *buf, size_t len)
{
char cmdbuf[3];
DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_VERSION_INFO;
@@ -240,42 +249,42 @@ qcdm_cmd_version_info_new (char *buf, gsize len, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_version_info_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_version_info_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdVersionInfoRsp *rsp = (DMCmdVersionInfoRsp *) buf;
char tmp[12];
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_VERSION_INFO, sizeof (DMCmdVersionInfoRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_VERSION_INFO, sizeof (DMCmdVersionInfoRsp), out_error))
return NULL;
result = qcdm_result_new ();
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->comp_date) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->comp_date) <= sizeof (tmp));
memcpy (tmp, rsp->comp_date, sizeof (rsp->comp_date));
qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_COMP_DATE, tmp);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->comp_time) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->comp_time) <= sizeof (tmp));
memcpy (tmp, rsp->comp_time, sizeof (rsp->comp_time));
qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_COMP_TIME, tmp);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->rel_date) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->rel_date) <= sizeof (tmp));
memcpy (tmp, rsp->rel_date, sizeof (rsp->rel_date));
qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_RELEASE_DATE, tmp);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->rel_time) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->rel_time) <= sizeof (tmp));
memcpy (tmp, rsp->rel_time, sizeof (rsp->rel_time));
qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_RELEASE_TIME, tmp);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->model) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->model) <= sizeof (tmp));
memcpy (tmp, rsp->model, sizeof (rsp->model));
qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_MODEL, tmp);
@@ -284,14 +293,14 @@ qcdm_cmd_version_info_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-gsize
-qcdm_cmd_esn_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_esn_new (char *buf, size_t len)
{
char cmdbuf[3];
DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_ESN;
@@ -299,21 +308,19 @@ qcdm_cmd_esn_new (char *buf, gsize len, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_esn_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_esn_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdEsnRsp *rsp = (DMCmdEsnRsp *) buf;
char *tmp;
- guint8 swapped[4];
+ u_int8_t swapped[4];
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_ESN, sizeof (DMCmdEsnRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_ESN, sizeof (DMCmdEsnRsp), out_error))
return NULL;
- result = qcdm_result_new ();
-
/* Convert the ESN from binary to a hex string; it's LE so we have to
* swap it to get the correct ordering.
*/
@@ -323,22 +330,25 @@ qcdm_cmd_esn_result (const char *buf, gsize len, GError **error)
swapped[3] = rsp->esn[0];
tmp = bin2hexstr (&swapped[0], sizeof (swapped));
- qcdm_result_add_string (result, QCDM_CMD_ESN_ITEM_ESN, tmp);
- g_free (tmp);
+ if (tmp != NULL) {
+ result = qcdm_result_new ();
+ qcdm_result_add_string (result, QCDM_CMD_ESN_ITEM_ESN, tmp);
+ free (tmp);
+ }
return result;
}
/**********************************************************************/
-gsize
-qcdm_cmd_cdma_status_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_cdma_status_new (char *buf, size_t len)
{
char cmdbuf[3];
DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_STATUS;
@@ -346,18 +356,18 @@ qcdm_cmd_cdma_status_new (char *buf, gsize len, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_cdma_status_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_cdma_status_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdStatusRsp *rsp = (DMCmdStatusRsp *) buf;
char *tmp;
- guint8 swapped[4];
- guint32 tmp_num;
+ u_int8_t swapped[4];
+ u_int32_t tmp_num;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_STATUS, sizeof (DMCmdStatusRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_STATUS, sizeof (DMCmdStatusRsp), out_error))
return NULL;
result = qcdm_result_new ();
@@ -372,44 +382,44 @@ qcdm_cmd_cdma_status_result (const char *buf, gsize len, GError **error)
tmp = bin2hexstr (&swapped[0], sizeof (swapped));
qcdm_result_add_string (result, QCDM_CMD_CDMA_STATUS_ITEM_ESN, tmp);
- g_free (tmp);
+ free (tmp);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->rf_mode);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->rf_mode);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE, tmp_num);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->cdma_rx_state);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->cdma_rx_state);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE, tmp_num);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->entry_reason);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->entry_reason);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON, tmp_num);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->curr_chan);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->curr_chan);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL, tmp_num);
- qcdm_result_add_uint8 (result, QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL, rsp->cdma_code_chan);
+ qcdm_result_add_u8 (result, QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL, rsp->cdma_code_chan);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->pilot_base);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->pilot_base);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE, tmp_num);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->sid);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_SID, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->sid);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_SID, tmp_num);
- tmp_num = (guint32) GUINT16_FROM_LE (rsp->nid);
- qcdm_result_add_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_NID, tmp_num);
+ tmp_num = (u_int32_t) le16toh (rsp->nid);
+ qcdm_result_add_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_NID, tmp_num);
return result;
}
/**********************************************************************/
-gsize
-qcdm_cmd_sw_version_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_sw_version_new (char *buf, size_t len)
{
char cmdbuf[3];
DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_SW_VERSION;
@@ -417,32 +427,32 @@ qcdm_cmd_sw_version_new (char *buf, gsize len, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_sw_version_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_sw_version_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdSwVersionRsp *rsp = (DMCmdSwVersionRsp *) buf;
char tmp[25];
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_SW_VERSION, sizeof (*rsp), error))
+ if (!check_command (buf, len, DIAG_CMD_SW_VERSION, sizeof (*rsp), out_error))
return NULL;
result = qcdm_result_new ();
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->version) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->version) <= sizeof (tmp));
memcpy (tmp, rsp->version, sizeof (rsp->version));
qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_VERSION, tmp);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->comp_date) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->comp_date) <= sizeof (tmp));
memcpy (tmp, rsp->comp_date, sizeof (rsp->comp_date));
qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_COMP_DATE, tmp);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (rsp->comp_time) <= sizeof (tmp));
+ qcdm_assert (sizeof (rsp->comp_time) <= sizeof (tmp));
memcpy (tmp, rsp->comp_time, sizeof (rsp->comp_time));
qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_COMP_TIME, tmp);
@@ -451,14 +461,14 @@ qcdm_cmd_sw_version_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-gsize
-qcdm_cmd_status_snapshot_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_status_snapshot_new (char *buf, size_t len)
{
char cmdbuf[3];
DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_STATUS_SNAPSHOT;
@@ -466,45 +476,45 @@ qcdm_cmd_status_snapshot_new (char *buf, gsize len, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-static guint8
-snapshot_state_to_qcdm (guint8 cdma_state)
+static u_int8_t
+snapshot_state_to_qcdm (u_int8_t cdma_state)
{
/* CDMA_STATUS_SNAPSHOT_STATE_* -> QCDM_STATUS_SNAPSHOT_STATE_* */
return cdma_state + 1;
}
-QCDMResult *
-qcdm_cmd_status_snapshot_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_status_snapshot_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdStatusSnapshotRsp *rsp = (DMCmdStatusSnapshotRsp *) buf;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_STATUS_SNAPSHOT, sizeof (*rsp), error))
+ if (!check_command (buf, len, DIAG_CMD_STATUS_SNAPSHOT, sizeof (*rsp), out_error))
return NULL;
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BAND_CLASS, cdma_band_class_to_qcdm (rsp->band_class));
- qcdm_result_add_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BASE_STATION_PREV, cdma_prev_to_qcdm (rsp->prev));
- qcdm_result_add_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_MOBILE_PREV, cdma_prev_to_qcdm (rsp->mob_prev));
- qcdm_result_add_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_PREV_IN_USE, cdma_prev_to_qcdm (rsp->prev_in_use));
- qcdm_result_add_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_STATE, snapshot_state_to_qcdm (rsp->state & 0xF));
+ qcdm_result_add_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BAND_CLASS, cdma_band_class_to_qcdm (rsp->band_class));
+ qcdm_result_add_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BASE_STATION_PREV, cdma_prev_to_qcdm (rsp->prev));
+ qcdm_result_add_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_MOBILE_PREV, cdma_prev_to_qcdm (rsp->mob_prev));
+ qcdm_result_add_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_PREV_IN_USE, cdma_prev_to_qcdm (rsp->prev_in_use));
+ qcdm_result_add_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_STATE, snapshot_state_to_qcdm (rsp->state & 0xF));
return result;
}
/**********************************************************************/
-gsize
-qcdm_cmd_pilot_sets_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_pilot_sets_new (char *buf, size_t len)
{
char cmdbuf[3];
DMCmdHeader *cmd = (DMCmdHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_PILOT_SETS;
@@ -517,7 +527,7 @@ qcdm_cmd_pilot_sets_new (char *buf, gsize len, GError **error)
#define PILOT_SETS_CMD_NEIGHBOR_SET "neighbor-set"
static const char *
-set_num_to_str (guint32 num)
+set_num_to_str (u_int32_t num)
{
if (num == QCDM_CMD_PILOT_SETS_TYPE_ACTIVE)
return PILOT_SETS_CMD_ACTIVE_SET;
@@ -528,88 +538,92 @@ set_num_to_str (guint32 num)
return NULL;
}
-QCDMResult *
-qcdm_cmd_pilot_sets_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_pilot_sets_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdPilotSetsRsp *rsp = (DMCmdPilotSetsRsp *) buf;
- GByteArray *array;
- gsize sets_len;
+ size_t sets_len;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_PILOT_SETS, sizeof (DMCmdPilotSetsRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_PILOT_SETS, sizeof (DMCmdPilotSetsRsp), out_error))
return NULL;
result = qcdm_result_new ();
sets_len = rsp->active_count * sizeof (DMCmdPilotSetsSet);
if (sets_len > 0) {
- array = g_byte_array_sized_new (sets_len);
- g_byte_array_append (array, (const guint8 *) &rsp->sets[0], sets_len);
- qcdm_result_add_boxed (result, PILOT_SETS_CMD_ACTIVE_SET, G_TYPE_BYTE_ARRAY, array);
+ qcdm_result_add_u8_array (result,
+ PILOT_SETS_CMD_ACTIVE_SET,
+ (const u_int8_t *) &rsp->sets[0],
+ sets_len);
}
sets_len = rsp->candidate_count * sizeof (DMCmdPilotSetsSet);
if (sets_len > 0) {
- array = g_byte_array_sized_new (sets_len);
- g_byte_array_append (array, (const guint8 *) &rsp->sets[rsp->active_count], sets_len);
- qcdm_result_add_boxed (result, PILOT_SETS_CMD_CANDIDATE_SET, G_TYPE_BYTE_ARRAY, array);
+ qcdm_result_add_u8_array (result,
+ PILOT_SETS_CMD_ACTIVE_SET,
+ (const u_int8_t *) &rsp->sets[rsp->active_count],
+ sets_len);
}
sets_len = rsp->neighbor_count * sizeof (DMCmdPilotSetsSet);
if (sets_len > 0) {
- array = g_byte_array_sized_new (sets_len);
- g_byte_array_append (array, (const guint8 *) &rsp->sets[rsp->active_count + rsp->candidate_count], sets_len);
- qcdm_result_add_boxed (result, PILOT_SETS_CMD_NEIGHBOR_SET, G_TYPE_BYTE_ARRAY, array);
+ qcdm_result_add_u8_array (result,
+ PILOT_SETS_CMD_ACTIVE_SET,
+ (const u_int8_t *) &rsp->sets[rsp->active_count + rsp->candidate_count],
+ sets_len);
}
return result;
}
-gboolean
-qcdm_cmd_pilot_sets_result_get_num (QCDMResult *result,
- guint32 set_type,
- guint32 *out_num)
+qcdmbool
+qcdm_cmd_pilot_sets_result_get_num (QcdmResult *result,
+ u_int32_t set_type,
+ u_int32_t *out_num)
{
const char *set_name;
- GByteArray *array = NULL;
+ const u_int8_t *array = NULL;
+ size_t array_len = 0;
- g_return_val_if_fail (result != NULL, FALSE);
+ qcdm_return_val_if_fail (result != NULL, FALSE);
set_name = set_num_to_str (set_type);
- g_return_val_if_fail (set_name != NULL, FALSE);
+ qcdm_return_val_if_fail (set_name != NULL, FALSE);
- if (!qcdm_result_get_boxed (result, set_name, (gpointer) &array))
+ if (!qcdm_result_get_u8_array (result, set_name, &array, &array_len))
return FALSE;
- *out_num = array->len / sizeof (DMCmdPilotSetsSet);
+ *out_num = array_len / sizeof (DMCmdPilotSetsSet);
return TRUE;
}
-gboolean
-qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result,
- guint32 set_type,
- guint32 num,
- guint32 *out_pn_offset,
- guint32 *out_ecio,
+qcdmbool
+qcdm_cmd_pilot_sets_result_get_pilot (QcdmResult *result,
+ u_int32_t set_type,
+ u_int32_t num,
+ u_int32_t *out_pn_offset,
+ u_int32_t *out_ecio,
float *out_db)
{
const char *set_name;
- GByteArray *array = NULL;
DMCmdPilotSetsSet *set;
+ const u_int8_t *array = NULL;
+ size_t array_len = 0;
- g_return_val_if_fail (result != NULL, FALSE);
+ qcdm_return_val_if_fail (result != NULL, FALSE);
set_name = set_num_to_str (set_type);
- g_return_val_if_fail (set_name != NULL, FALSE);
+ qcdm_return_val_if_fail (set_name != NULL, FALSE);
- if (!qcdm_result_get_boxed (result, set_name, (gpointer) &array))
+ if (!qcdm_result_get_u8_array (result, set_name, &array, &array_len))
return FALSE;
- g_return_val_if_fail (num < array->len / sizeof (DMCmdPilotSetsSet), FALSE);
+ qcdm_return_val_if_fail (num < array_len / sizeof (DMCmdPilotSetsSet), FALSE);
- set = (DMCmdPilotSetsSet *) &array->data[num * sizeof (DMCmdPilotSetsSet)];
+ set = (DMCmdPilotSetsSet *) &array[num * sizeof (DMCmdPilotSetsSet)];
*out_pn_offset = set->pn_offset;
*out_ecio = set->ecio;
/* EC/IO is in units of -0.5 dB per the specs */
@@ -619,19 +633,19 @@ qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result,
/**********************************************************************/
-gsize
-qcdm_cmd_nv_get_mdn_new (char *buf, gsize len, guint8 profile, GError **error)
+size_t
+qcdm_cmd_nv_get_mdn_new (char *buf, size_t len, u_int8_t profile)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
DMNVItemMdn *req;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_READ;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_DIR_NUMBER);
+ cmd->nv_item = htole16 (DIAG_NV_DIR_NUMBER);
req = (DMNVItemMdn *) &cmd->data[0];
req->profile = profile;
@@ -639,30 +653,30 @@ qcdm_cmd_nv_get_mdn_new (char *buf, gsize len, guint8 profile, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_get_mdn_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_get_mdn_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
DMNVItemMdn *mdn;
char tmp[11];
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd (rsp, DIAG_NV_DIR_NUMBER, error))
+ if (!check_nv_cmd (rsp, DIAG_NV_DIR_NUMBER, out_error))
return NULL;
mdn = (DMNVItemMdn *) &rsp->data[0];
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_MDN_ITEM_PROFILE, mdn->profile);
+ qcdm_result_add_u8 (result, QCDM_CMD_NV_GET_MDN_ITEM_PROFILE, mdn->profile);
memset (tmp, 0, sizeof (tmp));
- g_assert (sizeof (mdn->mdn) <= sizeof (tmp));
+ qcdm_assert (sizeof (mdn->mdn) <= sizeof (tmp));
memcpy (tmp, mdn->mdn, sizeof (mdn->mdn));
qcdm_result_add_string (result, QCDM_CMD_NV_GET_MDN_ITEM_MDN, tmp);
@@ -671,8 +685,8 @@ qcdm_cmd_nv_get_mdn_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-static gboolean
-roam_pref_validate (guint8 dm)
+static qcdmbool
+roam_pref_validate (u_int8_t dm)
{
if ( dm == DIAG_NV_ROAM_PREF_HOME_ONLY
|| dm == DIAG_NV_ROAM_PREF_ROAM_ONLY
@@ -681,19 +695,19 @@ roam_pref_validate (guint8 dm)
return FALSE;
}
-gsize
-qcdm_cmd_nv_get_roam_pref_new (char *buf, gsize len, guint8 profile, GError **error)
+size_t
+qcdm_cmd_nv_get_roam_pref_new (char *buf, size_t len, u_int8_t profile)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
DMNVItemRoamPref *req;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_READ;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_ROAM_PREF);
+ cmd->nv_item = htole16 (DIAG_NV_ROAM_PREF);
req = (DMNVItemRoamPref *) &cmd->data[0];
req->profile = profile;
@@ -701,60 +715,56 @@ qcdm_cmd_nv_get_roam_pref_new (char *buf, gsize len, guint8 profile, GError **er
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_get_roam_pref_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_get_roam_pref_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
DMNVItemRoamPref *roam;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd (rsp, DIAG_NV_ROAM_PREF, error))
+ if (!check_nv_cmd (rsp, DIAG_NV_ROAM_PREF, out_error))
return NULL;
roam = (DMNVItemRoamPref *) &rsp->data[0];
if (!roam_pref_validate (roam->roam_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Unknown roam preference 0x%X",
- roam->roam_pref);
+ qcdm_err (0, "Unknown roam preference 0x%X", roam->roam_pref);
return NULL;
}
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_PROFILE, roam->profile);
- qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF, roam->roam_pref);
+ qcdm_result_add_u8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_PROFILE, roam->profile);
+ qcdm_result_add_u8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF, roam->roam_pref);
return result;
}
-gsize
+size_t
qcdm_cmd_nv_set_roam_pref_new (char *buf,
- gsize len,
- guint8 profile,
- guint8 roam_pref,
- GError **error)
+ size_t len,
+ u_int8_t profile,
+ u_int8_t roam_pref)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
DMNVItemRoamPref *req;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
if (!roam_pref_validate (roam_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Invalid roam preference %d", roam_pref);
+ qcdm_err (0, "Invalid roam preference %d", roam_pref);
return 0;
}
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_WRITE;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_ROAM_PREF);
+ cmd->nv_item = htole16 (DIAG_NV_ROAM_PREF);
req = (DMNVItemRoamPref *) &cmd->data[0];
req->profile = profile;
@@ -763,15 +773,15 @@ qcdm_cmd_nv_set_roam_pref_new (char *buf,
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_set_roam_pref_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_set_roam_pref_result (const char *buf, size_t len, int *out_error)
{
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_ROAM_PREF, error))
+ if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_ROAM_PREF, out_error))
return NULL;
return qcdm_result_new ();
@@ -779,8 +789,8 @@ qcdm_cmd_nv_set_roam_pref_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-static gboolean
-mode_pref_validate (guint8 dm)
+static qcdmbool
+mode_pref_validate (u_int8_t dm)
{
if ( dm == DIAG_NV_MODE_PREF_1X_ONLY
|| dm == DIAG_NV_MODE_PREF_HDR_ONLY
@@ -789,19 +799,19 @@ mode_pref_validate (guint8 dm)
return FALSE;
}
-gsize
-qcdm_cmd_nv_get_mode_pref_new (char *buf, gsize len, guint8 profile, GError **error)
+size_t
+qcdm_cmd_nv_get_mode_pref_new (char *buf, size_t len, u_int8_t profile)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
DMNVItemModePref *req;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_READ;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_MODE_PREF);
+ cmd->nv_item = htole16 (DIAG_NV_MODE_PREF);
req = (DMNVItemModePref *) &cmd->data[0];
req->profile = profile;
@@ -809,60 +819,56 @@ qcdm_cmd_nv_get_mode_pref_new (char *buf, gsize len, guint8 profile, GError **er
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_get_mode_pref_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_get_mode_pref_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
DMNVItemModePref *mode;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd (rsp, DIAG_NV_MODE_PREF, error))
+ if (!check_nv_cmd (rsp, DIAG_NV_MODE_PREF, out_error))
return NULL;
mode = (DMNVItemModePref *) &rsp->data[0];
if (!mode_pref_validate (mode->mode_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Unknown mode preference 0x%X",
- mode->mode_pref);
+ qcdm_err (0, "Unknown mode preference 0x%X", mode->mode_pref);
return NULL;
}
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_PROFILE, mode->profile);
- qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF, mode->mode_pref);
+ qcdm_result_add_u8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_PROFILE, mode->profile);
+ qcdm_result_add_u8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF, mode->mode_pref);
return result;
}
-gsize
+size_t
qcdm_cmd_nv_set_mode_pref_new (char *buf,
- gsize len,
- guint8 profile,
- guint8 mode_pref,
- GError **error)
+ size_t len,
+ u_int8_t profile,
+ u_int8_t mode_pref)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
DMNVItemModePref *req;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
if (!mode_pref_validate (mode_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Invalid mode preference %d", mode_pref);
+ qcdm_err (0, "Invalid mode preference %d", mode_pref);
return 0;
}
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_WRITE;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_MODE_PREF);
+ cmd->nv_item = htole16 (DIAG_NV_MODE_PREF);
req = (DMNVItemModePref *) &cmd->data[0];
req->profile = profile;
@@ -871,15 +877,15 @@ qcdm_cmd_nv_set_mode_pref_new (char *buf,
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_set_mode_pref_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_set_mode_pref_result (const char *buf, size_t len, int *out_error)
{
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_MODE_PREF, error))
+ if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_MODE_PREF, out_error))
return NULL;
return qcdm_result_new ();
@@ -887,8 +893,8 @@ qcdm_cmd_nv_set_mode_pref_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-static gboolean
-hdr_rev_pref_validate (guint8 dm)
+static qcdmbool
+hdr_rev_pref_validate (u_int8_t dm)
{
if ( dm == DIAG_NV_HDR_REV_PREF_0
|| dm == DIAG_NV_HDR_REV_PREF_A
@@ -897,74 +903,70 @@ hdr_rev_pref_validate (guint8 dm)
return FALSE;
}
-gsize
-qcdm_cmd_nv_get_hdr_rev_pref_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_nv_get_hdr_rev_pref_new (char *buf, size_t len)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_READ;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_HDR_REV_PREF);
+ cmd->nv_item = htole16 (DIAG_NV_HDR_REV_PREF);
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_get_hdr_rev_pref_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_get_hdr_rev_pref_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf;
DMNVItemHdrRevPref *rev;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd (rsp, DIAG_NV_HDR_REV_PREF, error))
+ if (!check_nv_cmd (rsp, DIAG_NV_HDR_REV_PREF, out_error))
return NULL;
rev = (DMNVItemHdrRevPref *) &rsp->data[0];
if (!hdr_rev_pref_validate (rev->rev_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Unknown HDR revision preference 0x%X",
- rev->rev_pref);
+ qcdm_err (0, "Unknown HDR revision preference 0x%X", rev->rev_pref);
return NULL;
}
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_NV_GET_HDR_REV_PREF_ITEM_REV_PREF, rev->rev_pref);
+ qcdm_result_add_u8 (result, QCDM_CMD_NV_GET_HDR_REV_PREF_ITEM_REV_PREF, rev->rev_pref);
return result;
}
-gsize
+size_t
qcdm_cmd_nv_set_hdr_rev_pref_new (char *buf,
- gsize len,
- guint8 rev_pref,
- GError **error)
+ size_t len,
+ u_int8_t rev_pref)
{
char cmdbuf[sizeof (DMCmdNVReadWrite) + 2];
DMCmdNVReadWrite *cmd = (DMCmdNVReadWrite *) &cmdbuf[0];
DMNVItemHdrRevPref *req;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
if (!hdr_rev_pref_validate (rev_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Invalid HDR revision preference %d", rev_pref);
+ qcdm_err (0, "Invalid HDR revision preference %d", rev_pref);
return 0;
}
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_NV_WRITE;
- cmd->nv_item = GUINT16_TO_LE (DIAG_NV_HDR_REV_PREF);
+ cmd->nv_item = htole16 (DIAG_NV_HDR_REV_PREF);
req = (DMNVItemHdrRevPref *) &cmd->data[0];
req->rev_pref = rev_pref;
@@ -972,15 +974,15 @@ qcdm_cmd_nv_set_hdr_rev_pref_new (char *buf,
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nv_set_hdr_rev_pref_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nv_set_hdr_rev_pref_result (const char *buf, size_t len, int *out_error)
{
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error))
+ if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), out_error))
return NULL;
- if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_HDR_REV_PREF, error))
+ if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_HDR_REV_PREF, out_error))
return NULL;
return qcdm_result_new ();
@@ -988,157 +990,152 @@ qcdm_cmd_nv_set_hdr_rev_pref_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-gsize
-qcdm_cmd_cm_subsys_state_info_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_cm_subsys_state_info_new (char *buf, size_t len)
{
char cmdbuf[sizeof (DMCmdSubsysHeader) + 2];
DMCmdSubsysHeader *cmd = (DMCmdSubsysHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_SUBSYS;
cmd->subsys_id = DIAG_SUBSYS_CM;
- cmd->subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_CM_STATE_INFO);
+ cmd->subsys_cmd = htole16 (DIAG_SUBSYS_CM_STATE_INFO);
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_cm_subsys_state_info_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_cm_subsys_state_info_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdSubsysCMStateInfoRsp *rsp = (DMCmdSubsysCMStateInfoRsp *) buf;
- guint32 tmp_num;
- guint32 roam_pref;
+ u_int32_t tmp_num;
+ u_int32_t roam_pref;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysCMStateInfoRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysCMStateInfoRsp), out_error))
return NULL;
- roam_pref = (guint32) GUINT32_FROM_LE (rsp->roam_pref);
+ roam_pref = (u_int32_t) le32toh (rsp->roam_pref);
if (!roam_pref_validate (roam_pref)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Unknown roam preference 0x%X",
- roam_pref);
+ qcdm_err (0, "Unknown roam preference 0x%X", roam_pref);
return NULL;
}
result = qcdm_result_new ();
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->call_state);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->call_state);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->oper_mode);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->oper_mode);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->system_mode);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->system_mode);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->mode_pref);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->mode_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->band_pref);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->band_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF, tmp_num);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF, roam_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF, roam_pref);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->srv_domain_pref);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->srv_domain_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->acq_order_pref);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->acq_order_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->hybrid_pref);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->hybrid_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF, tmp_num);
- tmp_num = (guint32) GUINT32_FROM_LE (rsp->network_sel_mode_pref);
- qcdm_result_add_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF, tmp_num);
+ tmp_num = (u_int32_t) le32toh (rsp->network_sel_mode_pref);
+ qcdm_result_add_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF, tmp_num);
return result;
}
/**********************************************************************/
-gsize
-qcdm_cmd_hdr_subsys_state_info_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_hdr_subsys_state_info_new (char *buf, size_t len)
{
char cmdbuf[sizeof (DMCmdSubsysHeader) + 2];
DMCmdSubsysHeader *cmd = (DMCmdSubsysHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_SUBSYS;
cmd->subsys_id = DIAG_SUBSYS_HDR;
- cmd->subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_HDR_STATE_INFO);
+ cmd->subsys_cmd = htole16 (DIAG_SUBSYS_HDR_STATE_INFO);
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_hdr_subsys_state_info_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_hdr_subsys_state_info_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdSubsysHDRStateInfoRsp *rsp = (DMCmdSubsysHDRStateInfoRsp *) buf;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysHDRStateInfoRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysHDRStateInfoRsp), out_error))
return NULL;
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE, rsp->at_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE, rsp->session_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE, rsp->almp_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE, rsp->init_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE, rsp->idle_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE, rsp->connected_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE, rsp->route_update_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE, rsp->overhead_msg_state);
- qcdm_result_add_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE, rsp->hdr_hybrid_mode);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE, rsp->at_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE, rsp->session_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE, rsp->almp_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE, rsp->init_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE, rsp->idle_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE, rsp->connected_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE, rsp->route_update_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE, rsp->overhead_msg_state);
+ qcdm_result_add_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE, rsp->hdr_hybrid_mode);
return result;
}
/**********************************************************************/
-gsize
+size_t
qcdm_cmd_ext_logmask_new (char *buf,
- gsize len,
- GSList *items,
- guint16 maxlog,
- GError **error)
+ size_t len,
+ u_int32_t items[],
+ u_int16_t maxlog)
{
char cmdbuf[sizeof (DMCmdExtLogMask) + 2];
DMCmdExtLogMask *cmd = (DMCmdExtLogMask *) &cmdbuf[0];
- GSList *iter;
- guint16 highest = 0;
- gsize total = 3;
+ u_int16_t highest = 0;
+ size_t total = 3;
+ u_int32_t i;
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_EXT_LOGMASK;
- for (iter = items; iter; iter = g_slist_next (iter)) {
- guint32 item = GPOINTER_TO_UINT (iter->data);
-
- g_warn_if_fail (item > 0);
- g_warn_if_fail (item < 4095);
- cmd->mask[item / 8] |= 1 << item % 8;
+ for (i = 0; items[i] > 0; i++) {
+ qcdm_warn_if_fail (items[i] > 0);
+ qcdm_warn_if_fail (items[i] < 4095);
+ cmd->mask[items[i] / 8] |= 1 << items[i] % 8;
- if (item > highest)
- highest = item;
+ if (items[i] > highest)
+ highest = items[i];
}
- g_return_val_if_fail (highest <= maxlog, 0);
- cmd->len = GUINT16_TO_LE (maxlog);
+ qcdm_return_val_if_fail (highest <= maxlog, 0);
+ cmd->len = htole16 (maxlog);
total += maxlog / 8;
if (maxlog && maxlog % 8)
total++;
@@ -1146,23 +1143,20 @@ qcdm_cmd_ext_logmask_new (char *buf,
return dm_encapsulate_buffer (cmdbuf, total, sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_ext_logmask_result (const char *buf,
- gsize len,
- GError **error)
+QcdmResult *
+qcdm_cmd_ext_logmask_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdExtLogMask *rsp = (DMCmdExtLogMask *) buf;
- guint32 masklen = 0, maxlog = 0;
- gsize minlen = 0;
+ u_int32_t masklen = 0, maxlog = 0;
+ size_t minlen = 0;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
/* Ensure size is at least enough for the command header */
if (len < 1) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_LENGTH,
- "DM command %d response not long enough (got %zu, expected "
- "at least %d).", DIAG_CMD_EXT_LOGMASK, len, 3);
+ qcdm_err (0, "DM command %d response not long enough (got %zu, expected "
+ "at least %d).", DIAG_CMD_EXT_LOGMASK, len, 3);
return FALSE;
}
@@ -1175,48 +1169,47 @@ qcdm_cmd_ext_logmask_result (const char *buf,
minlen = 1;
else {
/* Ensure size is equal to max # of log items + 3 */
- maxlog = GUINT16_FROM_LE (rsp->len);
+ maxlog = le16toh (rsp->len);
masklen = maxlog / 8;
if (maxlog % 8)
masklen++;
if (len < (masklen + 3)) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_LENGTH,
- "DM command %d response not long enough (got %zu, expected "
- "at least %d).", DIAG_CMD_EXT_LOGMASK, len, masklen + 3);
+ qcdm_err (0, "DM command %d response not long enough (got %zu, expected "
+ "at least %d).", DIAG_CMD_EXT_LOGMASK, len, masklen + 3);
return FALSE;
}
minlen = masklen + 3;
}
- if (!check_command (buf, len, DIAG_CMD_EXT_LOGMASK, minlen, error))
+ if (!check_command (buf, len, DIAG_CMD_EXT_LOGMASK, minlen, out_error))
return NULL;
result = qcdm_result_new ();
if (minlen != 4)
- qcdm_result_add_uint32 (result, QCDM_CMD_EXT_LOGMASK_ITEM_MAX_ITEMS, maxlog);
+ qcdm_result_add_u32 (result, QCDM_CMD_EXT_LOGMASK_ITEM_MAX_ITEMS, maxlog);
return result;
}
-gboolean
-qcmd_cmd_ext_logmask_result_get_item (QCDMResult *result,
- guint16 item)
+qcdmbool
+qcmd_cmd_ext_logmask_result_get_item (QcdmResult *result,
+ u_int16_t item)
{
return FALSE;
}
/**********************************************************************/
-gsize
-qcdm_cmd_event_report_new (char *buf, gsize len, gboolean start, GError **error)
+size_t
+qcdm_cmd_event_report_new (char *buf, size_t len, qcdmbool start)
{
char cmdbuf[4];
DMCmdEventReport *cmd = (DMCmdEventReport *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_EVENT_REPORT;
@@ -1225,12 +1218,12 @@ qcdm_cmd_event_report_new (char *buf, gsize len, gboolean start, GError **error)
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_event_report_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_event_report_result (const char *buf, size_t len, int *out_error)
{
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_EVENT_REPORT, sizeof (DMCmdEventReport), error))
+ if (!check_command (buf, len, DIAG_CMD_EVENT_REPORT, sizeof (DMCmdEventReport), out_error))
return NULL;
return qcdm_result_new ();
@@ -1238,60 +1231,57 @@ qcdm_cmd_event_report_result (const char *buf, gsize len, GError **error)
/**********************************************************************/
-gsize
-qcdm_cmd_zte_subsys_status_new (char *buf, gsize len, GError **error)
+size_t
+qcdm_cmd_zte_subsys_status_new (char *buf, size_t len)
{
char cmdbuf[sizeof (DMCmdSubsysHeader) + 2];
DMCmdSubsysHeader *cmd = (DMCmdSubsysHeader *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
memset (cmd, 0, sizeof (*cmd));
cmd->code = DIAG_CMD_SUBSYS;
cmd->subsys_id = DIAG_SUBSYS_ZTE;
- cmd->subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_ZTE_STATUS);
+ cmd->subsys_cmd = htole16 (DIAG_SUBSYS_ZTE_STATUS);
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_zte_subsys_status_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_zte_subsys_status_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdSubsysZteStatusRsp *rsp = (DMCmdSubsysZteStatusRsp *) buf;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysZteStatusRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysZteStatusRsp), out_error))
return NULL;
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR, rsp->signal_ind);
+ qcdm_result_add_u8 (result, QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR, rsp->signal_ind);
return result;
}
/**********************************************************************/
-gsize
+size_t
qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf,
- gsize len,
- guint8 chipset,
- GError **error)
+ size_t len,
+ u_int8_t chipset)
{
char cmdbuf[sizeof (DMCmdSubsysNwSnapshotReq) + 2];
DMCmdSubsysNwSnapshotReq *cmd = (DMCmdSubsysNwSnapshotReq *) &cmdbuf[0];
- g_return_val_if_fail (buf != NULL, 0);
- g_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
+ qcdm_return_val_if_fail (buf != NULL, 0);
+ qcdm_return_val_if_fail (len >= sizeof (*cmd) + DIAG_TRAILER_LEN, 0);
/* Validate chipset */
if (chipset != QCDM_NW_CHIPSET_6500 && chipset != QCDM_NW_CHIPSET_6800) {
- g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER,
- "Unknown Novatel chipset 0x%X",
- chipset);
+ qcdm_err (0, "Unknown Novatel chipset 0x%X", chipset);
return 0;
}
@@ -1305,43 +1295,43 @@ qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf,
cmd->hdr.subsys_id = DIAG_SUBSYS_NW_CONTROL_6800;
break;
default:
- g_assert_not_reached ();
+ qcdm_assert_not_reached ();
}
- cmd->hdr.subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT);
+ cmd->hdr.subsys_cmd = htole16 (DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT);
cmd->technology = DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_CDMA_EVDO;
- cmd->snapshot_mask = GUINT32_TO_LE (0xFFFF);
+ cmd->snapshot_mask = htole32 (0xFFFF);
return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len);
}
-QCDMResult *
-qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf, gsize len, GError **error)
+QcdmResult *
+qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf, size_t len, int *out_error)
{
- QCDMResult *result = NULL;
+ QcdmResult *result = NULL;
DMCmdSubsysNwSnapshotRsp *rsp = (DMCmdSubsysNwSnapshotRsp *) buf;
DMCmdSubsysNwSnapshotCdma *cdma = (DMCmdSubsysNwSnapshotCdma *) &rsp->data;
- guint32 num;
- guint8 num8;
+ u_int32_t num;
+ u_int8_t num8;
- g_return_val_if_fail (buf != NULL, NULL);
+ qcdm_return_val_if_fail (buf != NULL, NULL);
- if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysNwSnapshotRsp), error))
+ if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysNwSnapshotRsp), out_error))
return NULL;
/* FIXME: check response_code when we know what it means */
result = qcdm_result_new ();
- num = GUINT32_FROM_LE (cdma->rssi);
- qcdm_result_add_uint32 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI, num);
+ num = le32toh (cdma->rssi);
+ qcdm_result_add_u32 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI, num);
num8 = cdma_prev_to_qcdm (cdma->prev);
- qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV, num8);
+ qcdm_result_add_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV, num8);
num8 = cdma_band_class_to_qcdm (cdma->band_class);
- qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS, num8);
+ qcdm_result_add_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS, num8);
- qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI, cdma->eri);
+ qcdm_result_add_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI, cdma->eri);
num8 = QCDM_HDR_REV_UNKNOWN;
switch (cdma->hdr_rev) {
@@ -1354,7 +1344,7 @@ qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf, gsize len, GErro
default:
break;
}
- qcdm_result_add_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, num8);
+ qcdm_result_add_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, num8);
return result;
}
diff --git a/libqcdm/src/commands.h b/libqcdm/src/commands.h
index 18a53a0e..84e9456d 100644
--- a/libqcdm/src/commands.h
+++ b/libqcdm/src/commands.h
@@ -18,8 +18,7 @@
#ifndef LIBQCDM_COMMANDS_H
#define LIBQCDM_COMMANDS_H
-#include <glib.h>
-
+#include "utils.h"
#include "result.h"
/**********************************************************************/
@@ -75,25 +74,21 @@ enum {
#define QCDM_CMD_VERSION_INFO_ITEM_RELEASE_TIME "release-time"
#define QCDM_CMD_VERSION_INFO_ITEM_MODEL "model"
-gsize qcdm_cmd_version_info_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_version_info_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_version_info_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_version_info_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
#define QCDM_CMD_ESN_ITEM_ESN "esn"
-gsize qcdm_cmd_esn_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_esn_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_esn_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_esn_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -127,13 +122,11 @@ enum {
#define QCDM_CMD_CDMA_STATUS_ITEM_SID "sid"
#define QCDM_CMD_CDMA_STATUS_ITEM_NID "nid"
-gsize qcdm_cmd_cdma_status_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_cdma_status_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_cdma_status_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_cdma_status_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -145,13 +138,11 @@ QCDMResult *qcdm_cmd_cdma_status_result (const char *buf,
#define QCDM_CMD_SW_VERSION_ITEM_COMP_DATE "comp-date"
#define QCDM_CMD_SW_VERSION_ITEM_COMP_TIME "comp-time"
-gsize qcdm_cmd_sw_version_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_sw_version_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_sw_version_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_sw_version_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -193,13 +184,11 @@ enum {
/* The protocol revision currently in-use. One of QCDM_STATUS_SNAPSHOT_STATE_* */
#define QCDM_CMD_STATUS_SNAPSHOT_ITEM_STATE "state"
-gsize qcdm_cmd_status_snapshot_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_status_snapshot_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_status_snapshot_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_status_snapshot_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -210,23 +199,21 @@ enum {
QCDM_CMD_PILOT_SETS_TYPE_NEIGHBOR = 3,
};
-gsize qcdm_cmd_pilot_sets_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_pilot_sets_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_pilot_sets_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_pilot_sets_result (const char *buf,
+ size_t len,
+ int *out_error);
-gboolean qcdm_cmd_pilot_sets_result_get_num (QCDMResult *result,
- guint32 set_type,
- guint32 *out_num);
+qcdmbool qcdm_cmd_pilot_sets_result_get_num (QcdmResult *result,
+ u_int32_t set_type,
+ u_int32_t *out_num);
-gboolean qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result,
- guint32 set_type,
- guint32 num,
- guint32 *out_pn_offset,
- guint32 *out_ecio,
+qcdmbool qcdm_cmd_pilot_sets_result_get_pilot (QcdmResult *result,
+ u_int32_t set_type,
+ u_int32_t num,
+ u_int32_t *out_pn_offset,
+ u_int32_t *out_ecio,
float *out_db);
/**********************************************************************/
@@ -234,14 +221,11 @@ gboolean qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result,
#define QCDM_CMD_NV_GET_MDN_ITEM_PROFILE "profile"
#define QCDM_CMD_NV_GET_MDN_ITEM_MDN "mdn"
-gsize qcdm_cmd_nv_get_mdn_new (char *buf,
- gsize len,
- guint8 profile,
- GError **error);
+size_t qcdm_cmd_nv_get_mdn_new (char *buf, size_t len, u_int8_t profile);
-QCDMResult *qcdm_cmd_nv_get_mdn_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_get_mdn_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -255,24 +239,22 @@ enum {
#define QCDM_CMD_NV_GET_ROAM_PREF_ITEM_PROFILE "profile"
#define QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF "roam-pref"
-gsize qcdm_cmd_nv_get_roam_pref_new (char *buf,
- gsize len,
- guint8 profile,
- GError **error);
+size_t qcdm_cmd_nv_get_roam_pref_new (char *buf,
+ size_t len,
+ u_int8_t profile);
-QCDMResult *qcdm_cmd_nv_get_roam_pref_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_get_roam_pref_result (const char *buf,
+ size_t len,
+ int *out_error);
-gsize qcdm_cmd_nv_set_roam_pref_new (char *buf,
- gsize len,
- guint8 profile,
- guint8 roam_pref,
- GError **error);
+size_t qcdm_cmd_nv_set_roam_pref_new (char *buf,
+ size_t len,
+ u_int8_t profile,
+ u_int8_t roam_pref);
-QCDMResult *qcdm_cmd_nv_set_roam_pref_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_set_roam_pref_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -286,24 +268,22 @@ enum {
#define QCDM_CMD_NV_GET_MODE_PREF_ITEM_PROFILE "profile"
#define QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF "mode-pref"
-gsize qcdm_cmd_nv_get_mode_pref_new (char *buf,
- gsize len,
- guint8 profile,
- GError **error);
+size_t qcdm_cmd_nv_get_mode_pref_new (char *buf,
+ size_t len,
+ u_int8_t profile);
-QCDMResult *qcdm_cmd_nv_get_mode_pref_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_get_mode_pref_result (const char *buf,
+ size_t len,
+ int *out_error);
-gsize qcdm_cmd_nv_set_mode_pref_new (char *buf,
- gsize len,
- guint8 profile,
- guint8 mode_pref,
- GError **error);
+size_t qcdm_cmd_nv_set_mode_pref_new (char *buf,
+ size_t len,
+ u_int8_t profile,
+ u_int8_t mode_pref);
-QCDMResult *qcdm_cmd_nv_set_mode_pref_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_set_mode_pref_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -316,22 +296,19 @@ enum {
#define QCDM_CMD_NV_GET_HDR_REV_PREF_ITEM_REV_PREF "rev-pref"
-gsize qcdm_cmd_nv_get_hdr_rev_pref_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_nv_get_hdr_rev_pref_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_nv_get_hdr_rev_pref_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_get_hdr_rev_pref_result (const char *buf,
+ size_t len,
+ int *out_error);
-gsize qcdm_cmd_nv_set_hdr_rev_pref_new (char *buf,
- gsize len,
- guint8 rev_pref,
- GError **error);
+size_t qcdm_cmd_nv_set_hdr_rev_pref_new (char *buf,
+ size_t len,
+ u_int8_t rev_pref);
-QCDMResult *qcdm_cmd_nv_set_hdr_rev_pref_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nv_set_hdr_rev_pref_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -391,13 +368,11 @@ enum {
#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF "hybrid-pref"
#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF "network-selection-pref"
-gsize qcdm_cmd_cm_subsys_state_info_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_cm_subsys_state_info_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_cm_subsys_state_info_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_cm_subsys_state_info_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -476,55 +451,49 @@ enum {
#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE "overhead-msg-state"
#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE "hdr-hybrid-mode"
-gsize qcdm_cmd_hdr_subsys_state_info_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_hdr_subsys_state_info_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_hdr_subsys_state_info_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_hdr_subsys_state_info_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
/* Max # of log items this device supports */
#define QCDM_CMD_EXT_LOGMASK_ITEM_MAX_ITEMS "max-items"
-gsize qcdm_cmd_ext_logmask_new (char *buf,
- gsize len,
- GSList *items,
- guint16 maxlog,
- GError **error);
+size_t qcdm_cmd_ext_logmask_new (char *buf,
+ size_t len,
+ u_int32_t items[], /* terminated by 0 */
+ u_int16_t maxlog);
-QCDMResult *qcdm_cmd_ext_logmask_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_ext_logmask_result (const char *buf,
+ size_t len,
+ int *out_error);
/* Returns TRUE if 'item' is set in the log mask */
-gboolean qcmd_cmd_ext_logmask_result_get_item (QCDMResult *result,
- guint16 item);
+qcdmbool qcmd_cmd_ext_logmask_result_get_item (QcdmResult *result,
+ u_int16_t item);
/**********************************************************************/
-gsize qcdm_cmd_event_report_new (char *buf,
- gsize len,
- gboolean start,
- GError **error);
+size_t qcdm_cmd_event_report_new (char *buf,
+ size_t len,
+ qcdmbool start);
-QCDMResult *qcdm_cmd_event_report_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_event_report_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
#define QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR "signal-indicator"
-gsize qcdm_cmd_zte_subsys_status_new (char *buf,
- gsize len,
- GError **error);
+size_t qcdm_cmd_zte_subsys_status_new (char *buf, size_t len);
-QCDMResult *qcdm_cmd_zte_subsys_status_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_zte_subsys_status_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
@@ -547,14 +516,13 @@ enum {
QCDM_NW_CHIPSET_6800 = 2,
};
-gsize qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf,
- gsize len,
- guint8 chipset,
- GError **error);
+size_t qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf,
+ size_t len,
+ u_int8_t chipset);
-QCDMResult *qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf,
- gsize len,
- GError **error);
+QcdmResult *qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf,
+ size_t len,
+ int *out_error);
/**********************************************************************/
diff --git a/libqcdm/src/dm-commands.h b/libqcdm/src/dm-commands.h
index d43f4013..e4bbc6ee 100644
--- a/libqcdm/src/dm-commands.h
+++ b/libqcdm/src/dm-commands.h
@@ -211,83 +211,83 @@ enum {
/* Generic DM command header */
struct DMCmdHeader {
- guint8 code;
+ u_int8_t code;
} __attribute__ ((packed));
typedef struct DMCmdHeader DMCmdHeader;
/* DIAG_CMD_SUBSYS */
struct DMCmdSubsysHeader {
- guint8 code;
- guint8 subsys_id;
- guint16 subsys_cmd;
+ u_int8_t code;
+ u_int8_t subsys_id;
+ u_int16_t subsys_cmd;
} __attribute__ ((packed));
typedef struct DMCmdSubsysHeader DMCmdSubsysHeader;
/* DIAG_CMD_NV_READ / DIAG_CMD_NV_WRITE */
struct DMCmdNVReadWrite {
- guint8 code;
- guint16 nv_item;
- guint8 data[128];
- guint16 status;
+ u_int8_t code;
+ u_int16_t nv_item;
+ u_int8_t data[128];
+ u_int16_t status;
} __attribute__ ((packed));
typedef struct DMCmdNVReadWrite DMCmdNVReadWrite;
/* DIAG_CMD_VERSION_INFO */
struct DMCmdVersionInfoRsp {
- guint8 code;
+ u_int8_t code;
char comp_date[11];
char comp_time[8];
char rel_date[11];
char rel_time[8];
char model[8];
- guint8 scm;
- guint8 mob_cai_rev;
- guint8 mob_model;
- guint16 mob_firmware_rev;
- guint8 slot_cycle_index;
- guint8 msm_ver;
- guint8 _unknown;
+ u_int8_t scm;
+ u_int8_t mob_cai_rev;
+ u_int8_t mob_model;
+ u_int16_t mob_firmware_rev;
+ u_int8_t slot_cycle_index;
+ u_int8_t msm_ver;
+ u_int8_t _unknown;
} __attribute__ ((packed));
typedef struct DMCmdVersionInfoRsp DMCmdVersionInfoRsp;
/* DIAG_CMD_ESN */
struct DMCmdEsnRsp {
- guint8 code;
- guint8 esn[4];
+ u_int8_t code;
+ u_int8_t esn[4];
} __attribute__ ((packed));
typedef struct DMCmdEsnRsp DMCmdEsnRsp;
/* DIAG_CMD_STATUS */
struct DMCmdStatusRsp {
- guint8 code;
- guint8 _unknown[3];
- guint8 esn[4];
- guint16 rf_mode;
- guint8 min1_analog[4];
- guint8 min1_cdma[4];
- guint8 min2_analog[2];
- guint8 min2_cdma[2];
- guint8 _unknown1;
- guint16 cdma_rx_state;
- guint8 good_frames;
- guint16 analog_corrected_frames;
- guint16 analog_bad_frames;
- guint16 analog_word_syncs;
- guint16 entry_reason;
- guint16 curr_chan;
- guint8 cdma_code_chan;
- guint16 pilot_base;
- guint16 sid;
- guint16 nid;
- guint16 analog_locaid;
- guint16 analog_rssi;
- guint8 analog_power;
+ u_int8_t code;
+ u_int8_t _unknown[3];
+ u_int8_t esn[4];
+ u_int16_t rf_mode;
+ u_int8_t min1_analog[4];
+ u_int8_t min1_cdma[4];
+ u_int8_t min2_analog[2];
+ u_int8_t min2_cdma[2];
+ u_int8_t _unknown1;
+ u_int16_t cdma_rx_state;
+ u_int8_t good_frames;
+ u_int16_t analog_corrected_frames;
+ u_int16_t analog_bad_frames;
+ u_int16_t analog_word_syncs;
+ u_int16_t entry_reason;
+ u_int16_t curr_chan;
+ u_int8_t cdma_code_chan;
+ u_int16_t pilot_base;
+ u_int16_t sid;
+ u_int16_t nid;
+ u_int16_t analog_locaid;
+ u_int16_t analog_rssi;
+ u_int8_t analog_power;
} __attribute__ ((packed));
typedef struct DMCmdStatusRsp DMCmdStatusRsp;
/* DIAG_CMD_SW_VERSION */
struct DMCmdSwVersionRsp {
- guint8 code;
+ u_int8_t code;
char version[20];
char comp_date[11];
char comp_time[8];
@@ -296,55 +296,55 @@ typedef struct DMCmdSwVersionRsp DMCmdSwVersionRsp;
/* DIAG_CMD_STATUS_SNAPSHOT */
struct DMCmdStatusSnapshotRsp {
- guint8 code;
- guint8 esn[4];
- guint8 imsi_s1[4];
- guint8 imsi_s2[2];
- guint8 imsi_s[8];
- guint8 imsi_11_12;
- guint16 mcc;
- guint8 imsi_addr_num;
- guint16 sid;
- guint16 nid;
- guint8 prev;
- guint8 prev_in_use;
- guint8 mob_prev;
- guint8 band_class;
- guint16 frequency;
- guint8 oper_mode;
- guint8 state;
- guint8 sub_state;
+ u_int8_t code;
+ u_int8_t esn[4];
+ u_int8_t imsi_s1[4];
+ u_int8_t imsi_s2[2];
+ u_int8_t imsi_s[8];
+ u_int8_t imsi_11_12;
+ u_int16_t mcc;
+ u_int8_t imsi_addr_num;
+ u_int16_t sid;
+ u_int16_t nid;
+ u_int8_t prev;
+ u_int8_t prev_in_use;
+ u_int8_t mob_prev;
+ u_int8_t band_class;
+ u_int16_t frequency;
+ u_int8_t oper_mode;
+ u_int8_t state;
+ u_int8_t sub_state;
} __attribute__ ((packed));
typedef struct DMCmdStatusSnapshotRsp DMCmdStatusSnapshotRsp;
/* DIAG_SUBSYS_CM_STATE_INFO subsys command */
struct DMCmdSubsysCMStateInfoRsp {
DMCmdSubsysHeader header;
- guint32 call_state;
- guint32 oper_mode;
- guint32 system_mode;
- guint32 mode_pref;
- guint32 band_pref;
- guint32 roam_pref;
- guint32 srv_domain_pref;
- guint32 acq_order_pref;
- guint32 hybrid_pref;
- guint32 network_sel_mode_pref;
+ u_int32_t call_state;
+ u_int32_t oper_mode;
+ u_int32_t system_mode;
+ u_int32_t mode_pref;
+ u_int32_t band_pref;
+ u_int32_t roam_pref;
+ u_int32_t srv_domain_pref;
+ u_int32_t acq_order_pref;
+ u_int32_t hybrid_pref;
+ u_int32_t network_sel_mode_pref;
} __attribute__ ((packed));
typedef struct DMCmdSubsysCMStateInfoRsp DMCmdSubsysCMStateInfoRsp;
/* DIAG_SUBSYS_HDR_STATE_INFO subsys command */
struct DMCmdSubsysHDRStateInfoRsp {
DMCmdSubsysHeader header;
- guint8 at_state;
- guint8 session_state;
- guint8 almp_state;
- guint8 init_state;
- guint8 idle_state;
- guint8 connected_state;
- guint8 route_update_state;
- guint8 overhead_msg_state;
- guint8 hdr_hybrid_mode;
+ u_int8_t at_state;
+ u_int8_t session_state;
+ u_int8_t almp_state;
+ u_int8_t init_state;
+ u_int8_t idle_state;
+ u_int8_t connected_state;
+ u_int8_t route_update_state;
+ u_int8_t overhead_msg_state;
+ u_int8_t hdr_hybrid_mode;
} __attribute__ ((packed));
typedef struct DMCmdSubsysHDRStateInfoRsp DMCmdSubsysHDRStateInfoRsp;
@@ -352,92 +352,92 @@ typedef struct DMCmdSubsysHDRStateInfoRsp DMCmdSubsysHDRStateInfoRsp;
/* DIAG_SUBSYS_ZTE_STATUS subsys command */
struct DMCmdSubsysZteStatusRsp {
DMCmdSubsysHeader header;
- guint8 _unknown1[8];
- guint8 signal_ind;
- guint8 _unknown2;
+ u_int8_t _unknown1[8];
+ u_int8_t signal_ind;
+ u_int8_t _unknown2;
} __attribute__ ((packed));
typedef struct DMCmdSubsysZteStatusRsp DMCmdSubsysZteStatusRsp;
/* DIAG_CMD_PILOT_SETS command */
struct DMCmdPilotSetsSet {
- guint16 pn_offset;
- guint16 ecio;
+ u_int16_t pn_offset;
+ u_int16_t ecio;
} __attribute__ ((packed));
typedef struct DMCmdPilotSetsSet DMCmdPilotSetsSet;
struct DMCmdPilotSetsRsp {
- guint8 code;
- guint16 pilot_inc;
- guint8 active_count;
- guint8 candidate_count;
- guint8 neighbor_count;
+ u_int8_t code;
+ u_int16_t pilot_inc;
+ u_int8_t active_count;
+ u_int8_t candidate_count;
+ u_int8_t neighbor_count;
DMCmdPilotSetsSet sets[52];
} __attribute__ ((packed));
typedef struct DMCmdPilotSetsRsp DMCmdPilotSetsRsp;
struct DMCmdExtLogMask {
- guint8 code;
+ u_int8_t code;
/* Bit number of highest '1' in 'mask'; set to 0 to get current mask. */
- guint16 len;
+ u_int16_t len;
/* Bitfield of log messages to receive */
- guint8 mask[512];
+ u_int8_t mask[512];
} __attribute__ ((packed));
typedef struct DMCmdExtLogMask DMCmdExtLogMask;
struct DMCmdEventReport {
- guint8 code;
- guint8 on;
+ u_int8_t code;
+ u_int8_t on;
} __attribute__ ((packed));
typedef struct DMCmdEventReport DMCmdEventReport;
struct DMCmdEventReportRsp {
- guint8 code;
- guint16 len;
- guint16 event_id;
- guint8 data[0];
+ u_int8_t code;
+ u_int16_t len;
+ u_int16_t event_id;
+ u_int8_t data[0];
} __attribute__ ((packed));
typedef struct DMCmdEventReportRsp DMCmdEventReportRsp;
/* DIAG_SUBSYS_NW_CONTROL_* subsys command */
struct DMCmdSubsysNwSnapshotReq {
DMCmdSubsysHeader hdr;
- guint8 technology; /* DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_* */
- guint32 snapshot_mask;
+ u_int8_t technology; /* DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_* */
+ u_int32_t snapshot_mask;
} __attribute__ ((packed));
typedef struct DMCmdSubsysNwSnapshotReq DMCmdSubsysNwSnapshotReq;
/* DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT response */
struct DMCmdSubsysNwSnapshotRsp {
DMCmdSubsysHeader hdr;
- guint8 response_code;
- guint32 bitfield1;
- guint32 bitfield2;
- guint8 data[100];
+ u_int8_t response_code;
+ u_int32_t bitfield1;
+ u_int32_t bitfield2;
+ u_int8_t data[100];
} __attribute__ ((packed));
typedef struct DMCmdSubsysNwSnapshotRsp DMCmdSubsysNwSnapshotRsp;
struct DMCmdSubsysNwSnapshotCdma {
- guint32 rssi;
- guint32 battery_level;
- guint8 call_info;
- guint8 new_sms_ind;
- guint8 missed_calls;
- guint32 voicemail_ind;
- guint8 pkt_call_ctrl_state;
- guint8 mip_rrp_err_code;
- guint8 cur_packet_zone_id;
- guint8 prev;
- guint8 band_class;
- guint8 eri;
- guint8 eri_alert_id;
- guint32 cur_call_total_time;
- guint32 cur_call_active_time;
- guint32 cur_call_tx_ip_bytes;
- guint32 cur_call_rx_ip_bytes;
- guint8 connection_status;
- guint16 dominant_pn;
- guint8 wdisable_mask;
- guint8 hdr_rev;
+ u_int32_t rssi;
+ u_int32_t battery_level;
+ u_int8_t call_info;
+ u_int8_t new_sms_ind;
+ u_int8_t missed_calls;
+ u_int32_t voicemail_ind;
+ u_int8_t pkt_call_ctrl_state;
+ u_int8_t mip_rrp_err_code;
+ u_int8_t cur_packet_zone_id;
+ u_int8_t prev;
+ u_int8_t band_class;
+ u_int8_t eri;
+ u_int8_t eri_alert_id;
+ u_int32_t cur_call_total_time;
+ u_int32_t cur_call_active_time;
+ u_int32_t cur_call_tx_ip_bytes;
+ u_int32_t cur_call_rx_ip_bytes;
+ u_int8_t connection_status;
+ u_int16_t dominant_pn;
+ u_int8_t wdisable_mask;
+ u_int8_t hdr_rev;
} __attribute__ ((packed));
typedef struct DMCmdSubsysNwSnapshotCdma DMCmdSubsysNwSnapshotCdma;
diff --git a/libqcdm/src/error.c b/libqcdm/src/error.c
deleted file mode 100644
index 994608e9..00000000
--- a/libqcdm/src/error.c
+++ /dev/null
@@ -1,88 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * Copyright (C) 2010 Red Hat, Inc.
- *
- * This program is free software: you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation
- *
- * 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/>.
- */
-
-#include "error.h"
-
-#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
-
-GQuark
-qcdm_serial_error_quark (void)
-{
- static GQuark ret = 0;
-
- if (ret == 0)
- ret = g_quark_from_static_string ("qcdm-serial-error");
-
- return ret;
-}
-
-GType
-qcdm_serial_error_get_type (void)
-{
- static GType etype = 0;
-
- if (etype == 0) {
- static const GEnumValue values[] = {
- ENUM_ENTRY (QCDM_SERIAL_CONFIG_FAILED, "SerialConfigFailed"),
- { 0, 0, 0 }
- };
-
- etype = g_enum_register_static ("QcdmSerialError", values);
- }
-
- return etype;
-}
-
-/***************************************************************/
-
-GQuark
-qcdm_command_error_quark (void)
-{
- static GQuark ret = 0;
-
- if (ret == 0)
- ret = g_quark_from_static_string ("qcdm-command-error");
-
- return ret;
-}
-
-GType
-qcdm_command_error_get_type (void)
-{
- static GType etype = 0;
-
- if (etype == 0) {
- static const GEnumValue values[] = {
- ENUM_ENTRY (QCDM_COMMAND_MALFORMED_RESPONSE, "QcdmCommandMalformedResponse"),
- ENUM_ENTRY (QCDM_COMMAND_UNEXPECTED, "QcdmCommandUnexpected"),
- ENUM_ENTRY (QCDM_COMMAND_BAD_LENGTH, "QcdmCommandBadLength"),
- ENUM_ENTRY (QCDM_COMMAND_BAD_COMMAND, "QcdmCommandBadCommand"),
- ENUM_ENTRY (QCDM_COMMAND_BAD_PARAMETER, "QcdmCommandBadParameter"),
- ENUM_ENTRY (QCDM_COMMAND_NOT_ACCEPTED, "QcdmCommandNotAccepted"),
- ENUM_ENTRY (QCDM_COMMAND_BAD_MODE, "QcdmCommandBadMode"),
- ENUM_ENTRY (QCDM_COMMAND_NVCMD_FAILED, "QcdmCommandNvCmdFailed"),
- ENUM_ENTRY (QCDM_COMMAND_SPC_LOCKED, "QcdmCommandSpcLocked"),
- { 0, 0, 0 }
- };
-
- etype = g_enum_register_static ("QcdmCommandError", values);
- }
-
- return etype;
-}
-
-
diff --git a/libqcdm/src/error.h b/libqcdm/src/error.h
deleted file mode 100644
index f0b05349..00000000
--- a/libqcdm/src/error.h
+++ /dev/null
@@ -1,54 +0,0 @@
-/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*
- * Copyright (C) 2010 Red Hat, Inc.
- *
- * This program is free software: you can redistribute it and/or
- * modify it under the terms of version 2 of the GNU General Public
- * License as published by the Free Software Foundation
- *
- * 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 LIBQCDM_ERROR_H
-#define LIBQCDM_ERROR_H
-
-#include <glib.h>
-#include <glib-object.h>
-
-enum {
- QCDM_SERIAL_CONFIG_FAILED = 0,
-};
-
-#define QCDM_SERIAL_ERROR (qcdm_serial_error_quark ())
-#define QCDM_TYPE_SERIAL_ERROR (qcdm_serial_error_get_type ())
-
-GQuark qcdm_serial_error_quark (void);
-GType qcdm_serial_error_get_type (void);
-
-
-enum {
- QCDM_COMMAND_MALFORMED_RESPONSE = 0,
- QCDM_COMMAND_UNEXPECTED = 1,
- QCDM_COMMAND_BAD_LENGTH = 2,
- QCDM_COMMAND_BAD_COMMAND = 3,
- QCDM_COMMAND_BAD_PARAMETER = 4,
- QCDM_COMMAND_NOT_ACCEPTED = 5,
- QCDM_COMMAND_BAD_MODE = 6,
- QCDM_COMMAND_NVCMD_FAILED = 7,
- QCDM_COMMAND_SPC_LOCKED = 8,
-};
-
-#define QCDM_COMMAND_ERROR (qcdm_command_error_quark ())
-#define QCDM_TYPE_COMMAND_ERROR (qcdm_command_error_get_type ())
-
-GQuark qcdm_command_error_quark (void);
-GType qcdm_command_error_get_type (void);
-
-#endif /* LIBQCDM_ERROR_H */
-
diff --git a/libqcdm/src/errors.c b/libqcdm/src/errors.c
new file mode 100644
index 00000000..12b8d552
--- /dev/null
+++ b/libqcdm/src/errors.c
@@ -0,0 +1,60 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * 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/>.
+ */
+
+#include "errors.h"
+#include <stdlib.h>
+#include <string.h>
+
+void
+_qcdm_log (const char *file,
+ int line,
+ const char *func,
+ int level,
+ int domain,
+ const char *format,
+ ...)
+{
+ va_list args;
+ char *message = NULL;
+ int n;
+ const char *prefix = "info";
+
+ qcdm_return_if_fail (format != NULL);
+ qcdm_return_if_fail (format[0] != '\0');
+
+ /* level & domain ignored for now */
+
+ if (getenv ("QCDM_DEBUG") == NULL)
+ return;
+
+ va_start (args, format);
+ n = vasprintf (&message, format, args);
+ va_end (args);
+
+ if (level & QCDM_LOGL_ERR)
+ prefix = "err";
+ else if (level & QCDM_LOGL_WARN)
+ prefix = "warn";
+ else if (level & QCDM_LOGL_DEBUG)
+ prefix = "dbg";
+
+ if (n >= 0) {
+ fprintf (stderr, "<%s> [%s:%u] %s(): %s\n", prefix, file, line, func, message);
+ free (message);
+ }
+}
+
diff --git a/libqcdm/src/errors.h b/libqcdm/src/errors.h
new file mode 100644
index 00000000..e275ae33
--- /dev/null
+++ b/libqcdm/src/errors.h
@@ -0,0 +1,94 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * Copyright (C) 2010 Red Hat, Inc.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation
+ *
+ * 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 LIBQCDM_ERROR_H
+#define LIBQCDM_ERROR_H
+
+#include <config.h>
+#include <sys/types.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdarg.h>
+
+enum {
+ QCDM_LOGL_ERR = 0x00000001,
+ QCDM_LOGL_WARN = 0x00000002,
+ QCDM_LOGL_INFO = 0x00000004,
+ QCDM_LOGL_DEBUG = 0x00000008
+};
+
+enum {
+ QCDM_SUCCESS = 0,
+ QCDM_ERROR_INVALID_ARGUMENTS = 1,
+ QCDM_ERROR_SERIAL_CONFIG_FAILED = 2,
+ QCDM_ERROR_VALUE_NOT_FOUND = 3,
+ QCDM_ERROR_RESPONSE_UNEXPECTED = 4,
+ QCDM_ERROR_RESPONSE_BAD_LENGTH = 5,
+ QCDM_ERROR_RESPONSE_MALFORMED = 6,
+ QCDM_ERROR_RESPONSE_BAD_COMMAND = 7,
+ QCDM_ERROR_RESPONSE_BAD_PARAMETER = 8,
+ QCDM_ERROR_RESPONSE_NOT_ACCEPTED = 9,
+ QCDM_ERROR_RESPONSE_BAD_MODE = 10,
+ QCDM_ERROR_NVCMD_FAILED = 11,
+ QCDM_ERROR_SPC_LOCKED = 12,
+};
+
+#define qcdm_assert assert
+#define qcdm_assert_not_reached() assert(0)
+
+#define qcdm_return_if_fail(e) \
+{ \
+ if (!(e)) { \
+ qcdm_warn (0, "failed: ##e##\n"); \
+ return; \
+ } \
+}
+
+#define qcdm_return_val_if_fail(e, v) \
+{ \
+ if (!(e)) { \
+ qcdm_warn (0, "failed: ##e##\n"); \
+ return v; \
+ } \
+}
+
+#define qcdm_warn_if_fail(e) \
+{ \
+ if (!(e)) { \
+ qcdm_warn (0, "failed: ##e##\n"); \
+ } \
+}
+
+void _qcdm_log (const char *file,
+ int line,
+ const char *func,
+ int domain,
+ int level,
+ const char *format,
+ ...) __attribute__((__format__ (__printf__, 6, 7)));
+
+#define qcdm_dbg(domain, ...) \
+ _qcdm_log (__FILE__, __LINE__, __func__, domain, QCDM_LOGL_DEBUG, ## __VA_ARGS__ )
+
+#define qcdm_warn(domain, ...) \
+ _qcdm_log (__FILE__, __LINE__, __func__, domain, QCDM_LOGL_WARN, ## __VA_ARGS__ )
+
+#define qcdm_err(domain, ...) \
+ _qcdm_log (__FILE__, __LINE__, __func__, domain, QCDM_LOGL_ERR, ## __VA_ARGS__ )
+
+#endif /* LIBQCDM_ERROR_H */
+
diff --git a/libqcdm/src/nv-items.h b/libqcdm/src/nv-items.h
index 45cdf9f3..ae91585c 100644
--- a/libqcdm/src/nv-items.h
+++ b/libqcdm/src/nv-items.h
@@ -18,6 +18,8 @@
#ifndef LIBQCDM_NV_ITEMS_H
#define LIBQCDM_NV_ITEMS_H
+#include <sys/types.h>
+
enum {
DIAG_NV_MODE_PREF = 10, /* Mode preference: 1x, HDR, auto */
DIAG_NV_DIR_NUMBER = 178, /* Mobile Directory Number (MDN) */
@@ -40,15 +42,15 @@ enum {
/* DIAG_NV_MODE_PREF */
struct DMNVItemModePref {
- guint8 profile;
- guint8 mode_pref;
+ u_int8_t profile;
+ u_int8_t mode_pref;
} __attribute__ ((packed));
typedef struct DMNVItemModePref DMNVItemModePref;
/* DIAG_NV_DIR_NUMBER */
struct DMNVItemMdn {
- guint8 profile;
- guint8 mdn[10];
+ u_int8_t profile;
+ u_int8_t mdn[10];
} __attribute__ ((packed));
typedef struct DMNVItemMdn DMNVItemMdn;
@@ -61,8 +63,8 @@ enum {
/* DIAG_NV_ROAM_PREF */
struct DMNVItemRoamPref {
- guint8 profile;
- guint8 roam_pref;
+ u_int8_t profile;
+ u_int8_t roam_pref;
} __attribute__ ((packed));
typedef struct DMNVItemRoamPref DMNVItemRoamPref;
@@ -75,7 +77,7 @@ enum {
/* DIAG_NV_HDR_REV_PREF */
struct DMNVItemHdrRevPref {
- guint8 rev_pref;
+ u_int8_t rev_pref;
} __attribute__ ((packed));
typedef struct DMNVItemHdrRevPref DMNVItemHdrRevPref;
diff --git a/libqcdm/src/result-private.h b/libqcdm/src/result-private.h
index 0db63f5e..009a451f 100644
--- a/libqcdm/src/result-private.h
+++ b/libqcdm/src/result-private.h
@@ -1,6 +1,6 @@
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
- * Copyright (C) 2010 Red Hat, Inc.
+ * Copyright (C) 2011 Red Hat, Inc.
*
* This program is free software: you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
@@ -18,34 +18,31 @@
#ifndef LIBQCDM_RESULT_PRIVATE_H
#define LIBQCDM_RESULT_PRIVATE_H
-#include <glib.h>
-#include <glib-object.h>
#include "result.h"
-QCDMResult *qcdm_result_new (void);
+QcdmResult *qcdm_result_new (void);
-/* For these functions, 'key' *must* be a constant, not allocated and freed */
-
-void qcdm_result_add_string (QCDMResult *result,
+void qcdm_result_add_string (QcdmResult *result,
const char *key,
const char *str);
-void qcdm_result_add_uint8 (QCDMResult *result,
+void qcdm_result_add_u8 (QcdmResult *result,
const char *key,
- guint8 num);
+ u_int8_t num);
-void qcdm_result_add_uint32 (QCDMResult *result,
- const char *key,
- guint32 num);
+void qcdm_result_add_u8_array (QcdmResult *result,
+ const char *key,
+ const u_int8_t *array,
+ size_t array_len);
-void qcdm_result_add_boxed (QCDMResult *result,
- const char *key,
- GType btype,
- gpointer boxed);
+int qcdm_result_get_u8_array (QcdmResult *result,
+ const char *key,
+ const u_int8_t **out_val,
+ size_t *out_len);
-gboolean qcdm_result_get_boxed (QCDMResult *result,
- const char *key,
- gpointer *out_val);
+void qcdm_result_add_u32 (QcdmResult *result,
+ const char *key,
+ u_int32_t num);
#endif /* LIBQCDM_RESULT_PRIVATE_H */
diff --git a/libqcdm/src/result.c b/libqcdm/src/result.c
index 2440478e..d278f019 100644
--- a/libqcdm/src/result.c
+++ b/libqcdm/src/result.c
@@ -16,233 +16,359 @@
*/
#include <string.h>
-#include <glib.h>
+#include <stdlib.h>
#include "result.h"
#include "result-private.h"
-#include "error.h"
-
-struct QCDMResult {
- guint32 refcount;
- GHashTable *hash;
+#include "errors.h"
+
+/*********************************************************/
+
+typedef struct Val Val;
+
+typedef enum {
+ VAL_TYPE_NONE = 0,
+ VAL_TYPE_STRING = 1,
+ VAL_TYPE_U8 = 2,
+ VAL_TYPE_U32 = 3,
+ VAL_TYPE_U8_ARRAY = 4,
+} ValType;
+
+struct Val {
+ char *key;
+ ValType type;
+ union {
+ char *s;
+ u_int8_t u8;
+ u_int32_t u32;
+ u_int8_t *u8_array;
+ } u;
+ u_int32_t array_len;
+ Val *next;
};
-
static void
-gvalue_destroy (gpointer data)
+val_free (Val *v)
{
- GValue *value = (GValue *) data;
-
- g_value_unset (value);
- g_slice_free (GValue, value);
+ if (v->type == VAL_TYPE_STRING) {
+ if (v->u.s)
+ free (v->u.s);
+ } else if (v->type == VAL_TYPE_U8_ARRAY) {
+ if (v->u.u8_array);
+ free (v->u.u8_array);
+ }
+ free (v->key);
+ memset (v, 0, sizeof (*v));
+ free (v);
}
-QCDMResult *
-qcdm_result_new (void)
+static Val *
+val_new_string (const char *key, const char *value)
{
- QCDMResult *result;
+ Val *v;
+
+ qcdm_return_val_if_fail (key != NULL, NULL);
+ qcdm_return_val_if_fail (key[0] != '\0', NULL);
+ qcdm_return_val_if_fail (value != NULL, NULL);
- g_type_init ();
+ v = calloc (sizeof (Val), 1);
+ if (v == NULL)
+ return NULL;
- result = g_malloc0 (sizeof (QCDMResult));
- result->hash = g_hash_table_new_full (g_str_hash, g_str_equal,
- NULL, gvalue_destroy);
- result->refcount = 1;
- return result;
+ v->key = strdup (key);
+ v->type = VAL_TYPE_STRING;
+ v->u.s = strdup (value);
+ return v;
}
-QCDMResult *
-qcdm_result_ref (QCDMResult *result)
+static Val *
+val_new_u8 (const char *key, u_int8_t u)
{
- g_return_val_if_fail (result != NULL, NULL);
- g_return_val_if_fail (result->refcount > 0, NULL);
+ Val *v;
- result->refcount++;
- return result;
+ qcdm_return_val_if_fail (key != NULL, NULL);
+ qcdm_return_val_if_fail (key[0] != '\0', NULL);
+
+ v = calloc (sizeof (Val), 1);
+ if (v == NULL)
+ return NULL;
+
+ v->key = strdup (key);
+ v->type = VAL_TYPE_U8;
+ v->u.u8 = u;
+ return v;
}
-void
-qcdm_result_unref (QCDMResult *result)
+static Val *
+val_new_u8_array (const char *key, const u_int8_t *array, size_t array_len)
{
- g_return_if_fail (result != NULL);
- g_return_if_fail (result->refcount > 0);
-
- result->refcount--;
- if (result->refcount == 0) {
- g_hash_table_destroy (result->hash);
- memset (result, 0, sizeof (QCDMResult));
- g_free (result);
+ Val *v;
+
+ qcdm_return_val_if_fail (key != NULL, NULL);
+ qcdm_return_val_if_fail (key[0] != '\0', NULL);
+ qcdm_return_val_if_fail (array != NULL, NULL);
+ qcdm_return_val_if_fail (array_len > 0, NULL);
+
+ v = calloc (sizeof (Val), 1);
+ if (v == NULL)
+ return NULL;
+
+ v->key = strdup (key);
+ v->type = VAL_TYPE_U8_ARRAY;
+ v->u.u8_array = malloc (array_len);
+ if (v->u.u8_array == NULL) {
+ val_free (v);
+ return NULL;
}
+ memcpy (v->u.u8_array, array, array_len);
+ v->array_len = array_len;
+
+ return v;
}
-void
-qcdm_result_add_string (QCDMResult *result,
- const char *key,
- const char *str)
+static Val *
+val_new_u32 (const char *key, u_int32_t u)
{
- GValue *val;
+ Val *v;
- g_return_if_fail (result != NULL);
- g_return_if_fail (result->refcount > 0);
- g_return_if_fail (key != NULL);
- g_return_if_fail (str != NULL);
+ qcdm_return_val_if_fail (key != NULL, NULL);
+ qcdm_return_val_if_fail (key[0] != '\0', NULL);
- val = g_slice_new0 (GValue);
- g_value_init (val, G_TYPE_STRING);
- g_value_set_string (val, str);
+ v = calloc (sizeof (Val), 1);
+ if (v == NULL)
+ return NULL;
- g_hash_table_insert (result->hash, (gpointer) key, val);
+ v->key = strdup (key);
+ v->type = VAL_TYPE_U32;
+ v->u.u32 = u;
+ return v;
}
-gboolean
-qcdm_result_get_string (QCDMResult *result,
- const char *key,
- const char **out_val)
+/*********************************************************/
+
+struct QcdmResult {
+ u_int32_t refcount;
+ Val *first;
+};
+
+QcdmResult *
+qcdm_result_new (void)
{
- GValue *val;
+ QcdmResult *r;
- g_return_val_if_fail (result != NULL, FALSE);
- g_return_val_if_fail (result->refcount > 0, FALSE);
- g_return_val_if_fail (key != NULL, FALSE);
- g_return_val_if_fail (out_val != NULL, FALSE);
- g_return_val_if_fail (*out_val == NULL, FALSE);
+ r = calloc (sizeof (QcdmResult), 1);
+ if (r)
+ r->refcount = 1;
+ return r;
+}
- val = g_hash_table_lookup (result->hash, key);
- if (!val)
- return FALSE;
+QcdmResult *
+qcdm_result_ref (QcdmResult *r)
+{
+ qcdm_return_val_if_fail (r != NULL, NULL);
+ qcdm_return_val_if_fail (r->refcount > 0, NULL);
- g_warn_if_fail (G_VALUE_HOLDS_STRING (val));
- if (!G_VALUE_HOLDS_STRING (val))
- return FALSE;
+ r->refcount++;
+ return r;
+}
- *out_val = g_value_get_string (val);
- return TRUE;
+static void
+qcdm_result_free (QcdmResult *r)
+{
+ Val *v, *n;
+
+ v = r->first;
+ while (v) {
+ n = v->next;
+ val_free (v);
+ v = n;
+ }
+ memset (r, 0, sizeof (*r));
+ free (r);
}
void
-qcdm_result_add_uint8 (QCDMResult *result,
- const char *key,
- guint8 num)
+qcdm_result_unref (QcdmResult *r)
{
- GValue *val;
+ qcdm_return_if_fail (r != NULL);
+ qcdm_return_if_fail (r->refcount > 0);
- g_return_if_fail (result != NULL);
- g_return_if_fail (result->refcount > 0);
- g_return_if_fail (key != NULL);
-
- val = g_slice_new0 (GValue);
- g_value_init (val, G_TYPE_UCHAR);
- g_value_set_uchar (val, (unsigned char) num);
+ r->refcount--;
+ if (r->refcount == 0)
+ qcdm_result_free (r);
+}
- g_hash_table_insert (result->hash, (gpointer) key, val);
+static Val *
+find_val (QcdmResult *r, const char *key, ValType expected_type)
+{
+ Val *v, *n;
+
+ v = r->first;
+ while (v) {
+ n = v->next;
+ if (strcmp (v->key, key) == 0) {
+ /* Check type */
+ qcdm_return_val_if_fail (v->type == expected_type, NULL);
+ return v;
+ }
+ v = n;
+ }
+ return NULL;
}
-gboolean
-qcdm_result_get_uint8 (QCDMResult *result,
- const char *key,
- guint8 *out_val)
+void
+qcdm_result_add_string (QcdmResult *r,
+ const char *key,
+ const char *str)
{
- GValue *val;
+ Val *v;
- g_return_val_if_fail (result != NULL, FALSE);
- g_return_val_if_fail (result->refcount > 0, FALSE);
- g_return_val_if_fail (key != NULL, FALSE);
- g_return_val_if_fail (out_val != NULL, FALSE);
+ qcdm_return_if_fail (r != NULL);
+ qcdm_return_if_fail (r->refcount > 0);
+ qcdm_return_if_fail (key != NULL);
+ qcdm_return_if_fail (str != NULL);
- val = g_hash_table_lookup (result->hash, key);
- if (!val)
- return FALSE;
+ v = val_new_string (key, str);
+ qcdm_return_if_fail (v != NULL);
+ v->next = r->first;
+ r->first = v;
+}
+
+int
+qcdm_result_get_string (QcdmResult *r,
+ const char *key,
+ const char **out_val)
+{
+ Val *v;
+
+ qcdm_return_val_if_fail (r != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (r->refcount > 0, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (key != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (out_val != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (*out_val == NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
- g_warn_if_fail (G_VALUE_HOLDS_UCHAR (val));
- if (!G_VALUE_HOLDS_UCHAR (val))
- return FALSE;
+ v = find_val (r, key, VAL_TYPE_STRING);
+ if (v == NULL)
+ return -QCDM_ERROR_VALUE_NOT_FOUND;
- *out_val = (guint8) g_value_get_uchar (val);
- return TRUE;
+ *out_val = v->u.s;
+ return 0;
}
void
-qcdm_result_add_uint32 (QCDMResult *result,
- const char *key,
- guint32 num)
+qcdm_result_add_u8 (QcdmResult *r,
+ const char *key,
+ u_int8_t num)
{
- GValue *val;
-
- g_return_if_fail (result != NULL);
- g_return_if_fail (result->refcount > 0);
- g_return_if_fail (key != NULL);
+ Val *v;
- val = g_slice_new0 (GValue);
- g_value_init (val, G_TYPE_UINT);
- g_value_set_uint (val, num);
+ qcdm_return_if_fail (r != NULL);
+ qcdm_return_if_fail (r->refcount > 0);
+ qcdm_return_if_fail (key != NULL);
- g_hash_table_insert (result->hash, (gpointer) key, val);
+ v = val_new_u8 (key, num);
+ qcdm_return_if_fail (v != NULL);
+ v->next = r->first;
+ r->first = v;
}
-gboolean
-qcdm_result_get_uint32 (QCDMResult *result,
- const char *key,
- guint32 *out_val)
+int
+qcdm_result_get_u8 (QcdmResult *r,
+ const char *key,
+ u_int8_t *out_val)
{
- GValue *val;
+ Val *v;
- g_return_val_if_fail (result != NULL, FALSE);
- g_return_val_if_fail (result->refcount > 0, FALSE);
- g_return_val_if_fail (key != NULL, FALSE);
- g_return_val_if_fail (out_val != NULL, FALSE);
+ qcdm_return_val_if_fail (r != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (r->refcount > 0, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (key != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (out_val != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
- val = g_hash_table_lookup (result->hash, key);
- if (!val)
- return FALSE;
+ v = find_val (r, key, VAL_TYPE_U8);
+ if (v == NULL)
+ return -QCDM_ERROR_VALUE_NOT_FOUND;
- g_warn_if_fail (G_VALUE_HOLDS_UINT (val));
- if (!G_VALUE_HOLDS_UINT (val))
- return FALSE;
-
- *out_val = (guint32) g_value_get_uint (val);
- return TRUE;
+ *out_val = v->u.u8;
+ return 0;
}
void
-qcdm_result_add_boxed (QCDMResult *result,
- const char *key,
- GType btype,
- gpointer boxed)
+qcdm_result_add_u8_array (QcdmResult *r,
+ const char *key,
+ const u_int8_t *array,
+ size_t array_len)
+{
+ Val *v;
+
+ qcdm_return_if_fail (r != NULL);
+ qcdm_return_if_fail (r->refcount > 0);
+ qcdm_return_if_fail (key != NULL);
+ qcdm_return_if_fail (array != NULL);
+ qcdm_return_if_fail (array_len >= 0);
+
+ v = val_new_u8_array (key, array, array_len);
+ qcdm_return_if_fail (v != NULL);
+ v->next = r->first;
+ r->first = v;
+}
+
+int
+qcdm_result_get_u8_array (QcdmResult *r,
+ const char *key,
+ const u_int8_t **out_val,
+ size_t *out_len)
{
- GValue *val;
+ Val *v;
- g_return_if_fail (result != NULL);
- g_return_if_fail (result->refcount > 0);
- g_return_if_fail (key != NULL);
+ qcdm_return_val_if_fail (r != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (r->refcount > 0, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (key != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (out_val != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (out_len != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
- val = g_slice_new0 (GValue);
- g_value_init (val, btype);
- g_value_set_static_boxed (val, boxed);
+ v = find_val (r, key, VAL_TYPE_U8_ARRAY);
+ if (v == NULL)
+ return -QCDM_ERROR_VALUE_NOT_FOUND;
- g_hash_table_insert (result->hash, (gpointer) key, val);
+ *out_val = v->u.u8_array;
+ *out_len = v->array_len;
+ return 0;
}
-gboolean
-qcdm_result_get_boxed (QCDMResult *result,
- const char *key,
- gpointer *out_val)
+void
+qcdm_result_add_u32 (QcdmResult *r,
+ const char *key,
+ u_int32_t num)
{
- GValue *val;
+ Val *v;
+
+ qcdm_return_if_fail (r != NULL);
+ qcdm_return_if_fail (r->refcount > 0);
+ qcdm_return_if_fail (key != NULL);
- g_return_val_if_fail (result != NULL, FALSE);
- g_return_val_if_fail (result->refcount > 0, FALSE);
- g_return_val_if_fail (key != NULL, FALSE);
- g_return_val_if_fail (out_val != NULL, FALSE);
+ v = val_new_u32 (key, num);
+ qcdm_return_if_fail (v != NULL);
+ v->next = r->first;
+ r->first = v;
+}
+
+int
+qcdm_result_get_u32 (QcdmResult *r,
+ const char *key,
+ u_int32_t *out_val)
+{
+ Val *v;
- val = g_hash_table_lookup (result->hash, key);
- if (!val)
- return FALSE;
+ qcdm_return_val_if_fail (r != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (r->refcount > 0, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (key != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
+ qcdm_return_val_if_fail (out_val != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
- g_warn_if_fail (G_VALUE_HOLDS_BOXED (val));
- if (!G_VALUE_HOLDS_BOXED (val))
- return FALSE;
+ v = find_val (r, key, VAL_TYPE_U32);
+ if (v == NULL)
+ return -QCDM_ERROR_VALUE_NOT_FOUND;
- *out_val = g_value_get_boxed (val);
- return TRUE;
+ *out_val = v->u.u32;
+ return 0;
}
diff --git a/libqcdm/src/result.h b/libqcdm/src/result.h
index 4912b07c..3ab2159a 100644
--- a/libqcdm/src/result.h
+++ b/libqcdm/src/result.h
@@ -18,25 +18,25 @@
#ifndef LIBQCDM_RESULT_H
#define LIBQCDM_RESULT_H
-#include <glib.h>
+#include <sys/types.h>
-typedef struct QCDMResult QCDMResult;
+typedef struct QcdmResult QcdmResult;
-gboolean qcdm_result_get_string (QCDMResult *result,
- const char *key,
- const char **out_val);
+int qcdm_result_get_string (QcdmResult *r,
+ const char *key,
+ const char **out_val);
-gboolean qcdm_result_get_uint8 (QCDMResult *result,
- const char *key,
- guint8 *out_val);
+int qcdm_result_get_u8 (QcdmResult *r,
+ const char *key,
+ u_int8_t *out_val);
-gboolean qcdm_result_get_uint32 (QCDMResult *result,
- const char *key,
- guint32 *out_val);
+int qcdm_result_get_u32 (QcdmResult *r,
+ const char *key,
+ u_int32_t *out_val);
-QCDMResult *qcdm_result_ref (QCDMResult *result);
+QcdmResult *qcdm_result_ref (QcdmResult *r);
-void qcdm_result_unref (QCDMResult *result);
+void qcdm_result_unref (QcdmResult *r);
#endif /* LIBQCDM_RESULT_H */
diff --git a/libqcdm/src/utils.c b/libqcdm/src/utils.c
index b5815482..922d1cb2 100644
--- a/libqcdm/src/utils.c
+++ b/libqcdm/src/utils.c
@@ -23,6 +23,7 @@
#include <string.h>
#include "utils.h"
+#include "errors.h"
/* QCDM protocol frames are pseudo Async HDLC frames which end with a 3-byte
* trailer. This trailer consists of the 16-bit CRC of the frame plus an ending
@@ -32,7 +33,7 @@
*/
/* Table of CRCs for each possible byte, with a generator polynomial of 0x8408 */
-const guint16 crc_table[256] = {
+const u_int16_t crc_table[256] = {
0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
@@ -68,10 +69,10 @@ const guint16 crc_table[256] = {
};
/* Calculate the CRC for a buffer using a seed of 0xffff */
-guint16
-crc16 (const char *buffer, gsize len)
+u_int16_t
+crc16 (const char *buffer, size_t len)
{
- guint16 crc = 0xffff;
+ u_int16_t crc = 0xffff;
while (len--)
crc = crc_table[(crc ^ *buffer++) & 0xff] ^ (crc >> 8);
@@ -84,20 +85,20 @@ crc16 (const char *buffer, gsize len)
/* Performs DM escaping on inbuf putting the result into outbuf, and returns
* the final length of the buffer.
*/
-gsize
+size_t
dm_escape (const char *inbuf,
- gsize inbuf_len,
+ size_t inbuf_len,
char *outbuf,
- gsize outbuf_len)
+ size_t outbuf_len)
{
const char *src = inbuf;
char *dst = outbuf;
size_t i = inbuf_len;
- g_return_val_if_fail (inbuf != NULL, 0);
- g_return_val_if_fail (inbuf_len > 0, 0);
- g_return_val_if_fail (outbuf != NULL, 0);
- g_return_val_if_fail (outbuf_len > inbuf_len, 0);
+ qcdm_return_val_if_fail (inbuf != NULL, 0);
+ qcdm_return_val_if_fail (inbuf_len > 0, 0);
+ qcdm_return_val_if_fail (outbuf != NULL, 0);
+ qcdm_return_val_if_fail (outbuf_len > inbuf_len, 0);
/* Since escaping potentially doubles the # of bytes, short-circuit the
* length check if destination buffer is clearly large enough. Note the
@@ -136,18 +137,18 @@ dm_escape (const char *inbuf,
return (dst - outbuf);
}
-gsize
+size_t
dm_unescape (const char *inbuf,
- gsize inbuf_len,
+ size_t inbuf_len,
char *outbuf,
- gsize outbuf_len,
- gboolean *escaping)
+ size_t outbuf_len,
+ qcdmbool *escaping)
{
size_t i, outsize;
- g_return_val_if_fail (inbuf_len > 0, 0);
- g_return_val_if_fail (outbuf_len >= inbuf_len, 0);
- g_return_val_if_fail (escaping != NULL, 0);
+ qcdm_return_val_if_fail (inbuf_len > 0, 0);
+ qcdm_return_val_if_fail (outbuf_len >= inbuf_len, 0);
+ qcdm_return_val_if_fail (escaping != NULL, 0);
for (i = 0, outsize = 0; i < inbuf_len; i++) {
if (*escaping) {
@@ -179,20 +180,20 @@ dm_unescape (const char *inbuf,
*
* Returns: size of the encapsulated QCDM command writted to @outbuf.
**/
-gsize
+size_t
dm_encapsulate_buffer (char *inbuf,
- gsize cmd_len,
- gsize inbuf_len,
+ size_t cmd_len,
+ size_t inbuf_len,
char *outbuf,
- gsize outbuf_len)
+ size_t outbuf_len)
{
- guint16 crc;
- gsize escaped_len;
+ u_int16_t crc;
+ size_t escaped_len;
- g_return_val_if_fail (inbuf != NULL, 0);
- g_return_val_if_fail (cmd_len >= 1, 0);
- g_return_val_if_fail (inbuf_len >= cmd_len + 2, 0); /* space for CRC */
- g_return_val_if_fail (outbuf != NULL, 0);
+ qcdm_return_val_if_fail (inbuf != NULL, 0);
+ qcdm_return_val_if_fail (cmd_len >= 1, 0);
+ qcdm_return_val_if_fail (inbuf_len >= cmd_len + 2, 0); /* space for CRC */
+ qcdm_return_val_if_fail (outbuf != NULL, 0);
/* Add the CRC */
crc = crc16 (inbuf, cmd_len);
@@ -200,7 +201,7 @@ dm_encapsulate_buffer (char *inbuf,
inbuf[cmd_len++] = (crc >> 8) & 0xFF;
escaped_len = dm_escape (inbuf, cmd_len, outbuf, outbuf_len);
- g_return_val_if_fail (outbuf_len > escaped_len, 0);
+ qcdm_return_val_if_fail (outbuf_len > escaped_len, 0);
outbuf[escaped_len++] = DIAG_CONTROL_CHAR;
return escaped_len;
@@ -230,25 +231,25 @@ dm_encapsulate_buffer (char *inbuf,
* all cases the caller should advance the buffer by the number of bytes
* returned in @out_used before calling this function again.
**/
-gboolean
+qcdmbool
dm_decapsulate_buffer (const char *inbuf,
- gsize inbuf_len,
+ size_t inbuf_len,
char *outbuf,
- gsize outbuf_len,
- gsize *out_decap_len,
- gsize *out_used,
- gboolean *out_need_more)
+ size_t outbuf_len,
+ size_t *out_decap_len,
+ size_t *out_used,
+ qcdmbool *out_need_more)
{
- gboolean escaping = FALSE;
- gsize i, pkt_len = 0, unesc_len;
- guint16 crc, pkt_crc;
-
- g_return_val_if_fail (inbuf != NULL, FALSE);
- g_return_val_if_fail (outbuf != NULL, FALSE);
- g_return_val_if_fail (outbuf_len > 0, FALSE);
- g_return_val_if_fail (out_decap_len != NULL, FALSE);
- g_return_val_if_fail (out_used != NULL, FALSE);
- g_return_val_if_fail (out_need_more != NULL, FALSE);
+ qcdmbool escaping = FALSE;
+ size_t i, pkt_len = 0, unesc_len;
+ u_int16_t crc, pkt_crc;
+
+ qcdm_return_val_if_fail (inbuf != NULL, FALSE);
+ qcdm_return_val_if_fail (outbuf != NULL, FALSE);
+ qcdm_return_val_if_fail (outbuf_len > 0, FALSE);
+ qcdm_return_val_if_fail (out_decap_len != NULL, FALSE);
+ qcdm_return_val_if_fail (out_used != NULL, FALSE);
+ qcdm_return_val_if_fail (out_need_more != NULL, FALSE);
*out_decap_len = 0;
*out_used = 0;
diff --git a/libqcdm/src/utils.h b/libqcdm/src/utils.h
index 5fccf7f9..e8cb0b75 100644
--- a/libqcdm/src/utils.h
+++ b/libqcdm/src/utils.h
@@ -18,37 +18,46 @@
#ifndef UTILS_H
#define UTILS_H
-#include <glib.h>
+#include <config.h>
+#include <sys/types.h>
+
+typedef u_int8_t qcdmbool;
+#ifndef TRUE
+#define TRUE ((u_int8_t) 1)
+#endif
+#ifndef FALSE
+#define FALSE ((u_int8_t) 0)
+#endif
#define DIAG_CONTROL_CHAR 0x7E
#define DIAG_TRAILER_LEN 3
-guint16 crc16 (const char *buffer, gsize len);
+u_int16_t crc16 (const char *buffer, size_t len);
-gsize dm_escape (const char *inbuf,
- gsize inbuf_len,
- char *outbuf,
- gsize outbuf_len);
+size_t dm_escape (const char *inbuf,
+ size_t inbuf_len,
+ char *outbuf,
+ size_t outbuf_len);
-gsize dm_unescape (const char *inbuf,
- gsize inbuf_len,
- char *outbuf,
- gsize outbuf_len,
- gboolean *escaping);
+size_t dm_unescape (const char *inbuf,
+ size_t inbuf_len,
+ char *outbuf,
+ size_t outbuf_len,
+ qcdmbool *escaping);
-gsize dm_encapsulate_buffer (char *inbuf,
- gsize cmd_len,
- gsize inbuf_len,
- char *outbuf,
- gsize outbuf_len);
+size_t dm_encapsulate_buffer (char *inbuf,
+ size_t cmd_len,
+ size_t inbuf_len,
+ char *outbuf,
+ size_t outbuf_len);
-gboolean dm_decapsulate_buffer (const char *inbuf,
- gsize inbuf_len,
+qcdmbool dm_decapsulate_buffer (const char *inbuf,
+ size_t inbuf_len,
char *outbuf,
- gsize outbuf_len,
- gsize *out_decap_len,
- gsize *out_used,
- gboolean *out_need_more);
+ size_t outbuf_len,
+ size_t *out_decap_len,
+ size_t *out_used,
+ qcdmbool *out_need_more);
#endif /* UTILS_H */
diff --git a/libqcdm/tests/test-qcdm-com.c b/libqcdm/tests/test-qcdm-com.c
index b95c7d9b..daccca16 100644
--- a/libqcdm/tests/test-qcdm-com.c
+++ b/libqcdm/tests/test-qcdm-com.c
@@ -29,7 +29,7 @@
#include "utils.h"
#include "result.h"
#include "commands.h"
-#include "error.h"
+#include "errors.h"
/************************************************************/
@@ -293,7 +293,8 @@ wait_reply (TestComData *d, char *buf, gsize len)
retries++;
continue;
} else if (bytes_read == 1) {
- gboolean more = FALSE, success;
+ qcdmbool more = FALSE;
+ gboolean success;
gsize used = 0;
total++;
@@ -328,17 +329,12 @@ void
test_com_port_init (void *f, void *data)
{
TestComData *d = data;
- GError *error = NULL;
- gboolean success;
+ int err;
- success = qcdm_port_setup (d->fd, &error);
- if (!success) {
- g_warning ("%s: error setting up port: (%d) %s",
- d->port,
- error ? error->code : -1,
- error && error->message ? error->message : "(unknown)");
- }
- g_assert (success);
+ err = qcdm_port_setup (d->fd);
+ if (err != QCDM_SUCCESS)
+ g_warning ("%s: error setting up port: %d", d->port, err);
+ g_assert (err == QCDM_SUCCESS);
}
void
@@ -346,14 +342,13 @@ test_com_version_info (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
char buf[512];
const char *str;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- len = qcdm_cmd_version_info_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_version_info_new (buf, sizeof (buf));
g_assert (len == 4);
/* Send the command */
@@ -364,7 +359,7 @@ test_com_version_info (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_version_info_result (buf, reply_len, &error);
+ result = qcdm_cmd_version_info_result (buf, reply_len, NULL);
g_assert (result);
g_print ("\n");
@@ -397,14 +392,13 @@ test_com_esn (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
char buf[512];
const char *str;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- len = qcdm_cmd_esn_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_esn_new (buf, sizeof (buf));
g_assert (len == 4);
/* Send the command */
@@ -415,7 +409,7 @@ test_com_esn (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_esn_result (buf, reply_len, &error);
+ result = qcdm_cmd_esn_result (buf, reply_len, NULL);
g_assert (result);
g_print ("\n");
@@ -432,14 +426,14 @@ test_com_mdn (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
char buf[512];
const char *str;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
+ int err = QCDM_SUCCESS;
- len = qcdm_cmd_nv_get_mdn_new (buf, sizeof (buf), 0, NULL);
+ len = qcdm_cmd_nv_get_mdn_new (buf, sizeof (buf), 0);
g_assert (len > 0);
/* Send the command */
@@ -450,9 +444,9 @@ test_com_mdn (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_nv_get_mdn_result (buf, reply_len, &error);
+ result = qcdm_cmd_nv_get_mdn_result (buf, reply_len, &err);
if (!result) {
- g_assert_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_NVCMD_FAILED);
+ g_assert_cmpint (err, ==, -QCDM_ERROR_NVCMD_FAILED);
return;
}
@@ -470,15 +464,15 @@ test_com_read_roam_pref (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[512];
guint8 pref;
const char *msg;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- len = qcdm_cmd_nv_get_roam_pref_new (buf, sizeof (buf), 0, NULL);
+ len = qcdm_cmd_nv_get_roam_pref_new (buf, sizeof (buf), 0);
g_assert (len > 0);
/* Send the command */
@@ -489,15 +483,16 @@ test_com_read_roam_pref (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_nv_get_roam_pref_result (buf, reply_len, &error);
- if (error && (error->code == QCDM_COMMAND_NVCMD_FAILED))
+ result = qcdm_cmd_nv_get_roam_pref_result (buf, reply_len, &err);
+ if (!result) {
+ g_assert_cmpint (err, ==, -QCDM_ERROR_NVCMD_FAILED);
return;
-
+ }
g_assert (result);
g_print ("\n");
- success = qcdm_result_get_uint8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF, &pref);
+ success = qcdm_result_get_u8 (result, QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF, &pref);
g_assert (success);
switch (pref) {
@@ -523,15 +518,15 @@ test_com_read_mode_pref (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[512];
guint8 pref;
const char *msg;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- len = qcdm_cmd_nv_get_mode_pref_new (buf, sizeof (buf), 0, NULL);
+ len = qcdm_cmd_nv_get_mode_pref_new (buf, sizeof (buf), 0);
g_assert (len > 0);
/* Send the command */
@@ -542,17 +537,15 @@ test_com_read_mode_pref (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_nv_get_mode_pref_result (buf, reply_len, &error);
+ result = qcdm_cmd_nv_get_mode_pref_result (buf, reply_len, &err);
if (!result) {
- g_assert (error);
- g_assert (error->domain == QCDM_COMMAND_ERROR);
- g_assert (error->code == QCDM_COMMAND_NVCMD_FAILED || error->code == QCDM_COMMAND_BAD_PARAMETER);
+ g_assert (err == -QCDM_ERROR_NVCMD_FAILED || err == -QCDM_ERROR_RESPONSE_BAD_PARAMETER);
return;
}
g_print ("\n");
- success = qcdm_result_get_uint8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF, &pref);
+ success = qcdm_result_get_u8 (result, QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF, &pref);
g_assert (success);
switch (pref) {
@@ -579,15 +572,15 @@ test_com_read_hdr_rev_pref (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[512];
guint8 pref;
const char *msg;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- len = qcdm_cmd_nv_get_hdr_rev_pref_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_nv_get_hdr_rev_pref_new (buf, sizeof (buf));
g_assert (len > 0);
/* Send the command */
@@ -598,17 +591,15 @@ test_com_read_hdr_rev_pref (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_nv_get_hdr_rev_pref_result (buf, reply_len, &error);
+ result = qcdm_cmd_nv_get_hdr_rev_pref_result (buf, reply_len, &err);
if (!result) {
- g_assert (error);
- g_assert (error->domain == QCDM_COMMAND_ERROR);
- g_assert (error->code == QCDM_COMMAND_NVCMD_FAILED || error->code == QCDM_COMMAND_BAD_PARAMETER);
+ g_assert (err == -QCDM_ERROR_NVCMD_FAILED || err == -QCDM_ERROR_RESPONSE_BAD_PARAMETER);
return;
}
g_print ("\n");
- success = qcdm_result_get_uint8 (result, QCDM_CMD_NV_GET_HDR_REV_PREF_ITEM_REV_PREF, &pref);
+ success = qcdm_result_get_u8 (result, QCDM_CMD_NV_GET_HDR_REV_PREF_ITEM_REV_PREF, &pref);
g_assert (success);
switch (pref) {
@@ -635,16 +626,16 @@ test_com_status (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[100];
const char *str, *detail;
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint32 n32;
guint8 n8;
- len = qcdm_cmd_cdma_status_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_cdma_status_new (buf, sizeof (buf));
g_assert (len == 4);
/* Send the command */
@@ -655,7 +646,7 @@ test_com_status (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_cdma_status_result (buf, reply_len, &error);
+ result = qcdm_cmd_cdma_status_result (buf, reply_len, &err);
g_assert (result);
g_print ("\n");
@@ -666,7 +657,7 @@ test_com_status (void *f, void *data)
n32 = 0;
detail = NULL;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE, &n32);
switch (n32) {
case QCDM_CMD_CDMA_STATUS_RF_MODE_ANALOG:
detail = "analog";
@@ -694,7 +685,7 @@ test_com_status (void *f, void *data)
n32 = 0;
detail = NULL;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE, &n32);
switch (n32) {
case QCDM_CMD_CDMA_STATUS_RX_STATE_ENTERING_CDMA:
detail = "entering CDMA";
@@ -721,27 +712,27 @@ test_com_status (void *f, void *data)
g_message ("%s: CDMA RX State: %u (%s)", __func__, n32, detail);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON, &n32);
g_message ("%s: Entry Reason: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL, &n32);
g_message ("%s: Current Channel: %u", __func__, n32);
n8 = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL, &n8);
+ qcdm_result_get_u8 (result, QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL, &n8);
g_message ("%s: Code Channel: %u", __func__, n8);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE, &n32);
g_message ("%s: Pilot Base: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_SID, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_SID, &n32);
g_message ("%s: CDMA System ID: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CDMA_STATUS_ITEM_NID, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CDMA_STATUS_ITEM_NID, &n32);
g_message ("%s: CDMA Network ID: %u", __func__, n32);
qcdm_result_unref (result);
@@ -752,13 +743,13 @@ test_com_sw_version (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[100];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- len = qcdm_cmd_sw_version_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_sw_version_new (buf, sizeof (buf));
g_assert (len == 4);
/* Send the command */
@@ -769,11 +760,11 @@ test_com_sw_version (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_sw_version_result (buf, reply_len, &error);
+ result = qcdm_cmd_sw_version_result (buf, reply_len, &err);
/* Recent devices don't appear to implement this command */
g_assert (result == NULL);
- g_assert_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND);
+ g_assert_cmpint (err, ==, -QCDM_ERROR_RESPONSE_BAD_COMMAND);
/*
str = NULL;
@@ -797,14 +788,14 @@ test_com_status_snapshot (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[100];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint8 n8;
- len = qcdm_cmd_status_snapshot_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_status_snapshot_new (buf, sizeof (buf));
g_assert (len == 4);
/* Send the command */
@@ -815,29 +806,29 @@ test_com_status_snapshot (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_status_snapshot_result (buf, reply_len, &error);
+ result = qcdm_cmd_status_snapshot_result (buf, reply_len, &err);
g_assert (result);
g_print ("\n");
n8 = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BAND_CLASS, &n8);
+ qcdm_result_get_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BAND_CLASS, &n8);
g_message ("%s: Band Class: %s", __func__, band_class_to_string (n8));
n8 = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BASE_STATION_PREV, &n8);
+ qcdm_result_get_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_BASE_STATION_PREV, &n8);
g_message ("%s: Base station P_REV: %s", __func__, prev_to_string (n8));
n8 = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_MOBILE_PREV, &n8);
+ qcdm_result_get_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_MOBILE_PREV, &n8);
g_message ("%s: Mobile P_REV: %s", __func__, prev_to_string (n8));
n8 = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_PREV_IN_USE, &n8);
+ qcdm_result_get_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_PREV_IN_USE, &n8);
g_message ("%s: P_REV in-use: %s", __func__, prev_to_string (n8));
n8 = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_STATE, &n8);
+ qcdm_result_get_u8 (result, QCDM_CMD_STATUS_SNAPSHOT_ITEM_STATE, &n8);
g_message ("%s: State: %d (%s)", __func__, n8, status_snapshot_state_to_string (n8));
qcdm_result_unref (result);
@@ -848,14 +839,14 @@ test_com_pilot_sets (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[256];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint32 num, i;
- len = qcdm_cmd_pilot_sets_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_pilot_sets_new (buf, sizeof (buf));
g_assert (len == 4);
/* Send the command */
@@ -866,7 +857,7 @@ test_com_pilot_sets (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_pilot_sets_result (buf, reply_len, &error);
+ result = qcdm_cmd_pilot_sets_result (buf, reply_len, &err);
g_assert (result);
num = 0;
@@ -902,15 +893,15 @@ test_com_cm_subsys_state_info (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[100];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint32 n32;
const char *detail;
- len = qcdm_cmd_cm_subsys_state_info_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_cm_subsys_state_info_new (buf, sizeof (buf));
g_assert (len == 7);
/* Send the command */
@@ -921,18 +912,18 @@ test_com_cm_subsys_state_info (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Parse the response into a result structure */
- result = qcdm_cmd_cm_subsys_state_info_result (buf, reply_len, &error);
+ result = qcdm_cmd_cm_subsys_state_info_result (buf, reply_len, &err);
g_assert (result);
g_print ("\n");
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE, &n32);
g_message ("%s: Call State: %u", __func__, n32);
n32 = 0;
detail = NULL;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE, &n32);
switch (n32) {
case QCDM_CMD_CM_SUBSYS_STATE_INFO_OPERATING_MODE_ONLINE:
detail = "online";
@@ -945,7 +936,7 @@ test_com_cm_subsys_state_info (void *f, void *data)
n32 = 0;
detail = NULL;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE, &n32);
switch (n32) {
case QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_NO_SERVICE:
detail = "no service";
@@ -972,7 +963,7 @@ test_com_cm_subsys_state_info (void *f, void *data)
g_message ("%s: System Mode: %u (%s)", __func__, n32, detail);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF, &n32);
switch (n32) {
case QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_DIGITAL_ONLY:
detail = "digital only";
@@ -993,11 +984,11 @@ test_com_cm_subsys_state_info (void *f, void *data)
g_message ("%s: Mode Preference: 0x%02X (%s)", __func__, n32 & 0xFF, detail);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF, &n32);
g_message ("%s: Band Preference: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF, &n32);
switch (n32) {
case QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_HOME_ONLY:
detail = "home only";
@@ -1014,19 +1005,19 @@ test_com_cm_subsys_state_info (void *f, void *data)
g_message ("%s: Roam Preference: 0x%02X (%s)", __func__, n32 & 0xFF, detail);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF, &n32);
g_message ("%s: Service Domain Preference: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF, &n32);
g_message ("%s: Acquisition Order Preference: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_HYBRID_PREF, &n32);
g_message ("%s: Hybrid Preference: %u", __func__, n32);
n32 = 0;
- qcdm_result_get_uint32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF, &n32);
+ qcdm_result_get_u32 (result, QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_NETWORK_SELECTION_PREF, &n32);
g_message ("%s: Network Selection Preference: %u", __func__, n32);
qcdm_result_unref (result);
@@ -1037,15 +1028,15 @@ test_com_hdr_subsys_state_info (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[100];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint8 num;
const char *detail;
- len = qcdm_cmd_hdr_subsys_state_info_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_hdr_subsys_state_info_new (buf, sizeof (buf));
g_assert (len == 7);
/* Send the command */
@@ -1058,10 +1049,10 @@ test_com_hdr_subsys_state_info (void *f, void *data)
g_print ("\n");
/* Parse the response into a result structure */
- result = qcdm_cmd_hdr_subsys_state_info_result (buf, reply_len, &error);
+ result = qcdm_cmd_hdr_subsys_state_info_result (buf, reply_len, &err);
if (!result) {
/* 1x-only devices won't implement the HDR subsystem of course */
- g_assert_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND);
+ g_assert_cmpint (err, ==, -QCDM_ERROR_RESPONSE_BAD_COMMAND);
g_message ("%s: device does not implement the HDR subsystem", __func__);
return;
}
@@ -1069,7 +1060,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_INACTIVE:
detail = "inactive";
@@ -1097,7 +1088,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_CLOSED:
detail = "closed";
@@ -1125,7 +1116,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_INACTIVE:
detail = "inactive";
@@ -1147,7 +1138,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_INACTIVE:
detail = "inactive";
@@ -1169,7 +1160,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_INACTIVE:
detail = "inactive";
@@ -1191,7 +1182,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_INACTIVE:
detail = "inactive";
@@ -1210,7 +1201,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_INACTIVE:
detail = "inactive";
@@ -1229,7 +1220,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
num = 0;
detail = NULL;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG_STATE, &num);
switch (num) {
case QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_INIT:
detail = "initial";
@@ -1247,7 +1238,7 @@ test_com_hdr_subsys_state_info (void *f, void *data)
g_message ("%s: Overhead Msg State: %u (%s)", __func__, num, detail);
num = 0;
- qcdm_result_get_uint8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE, &num);
+ qcdm_result_get_u8 (result, QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_HDR_HYBRID_MODE, &num);
g_message ("%s: HDR Hybrid Mode: %u", __func__, num);
qcdm_result_unref (result);
@@ -1258,16 +1249,16 @@ test_com_ext_logmask (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[520];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
- GSList *items = NULL;
+ u_int32_t items[] = { 0x002C, 0x002E, 0 };
guint32 maxlog = 0;
/* First get # of items the device supports */
- len = qcdm_cmd_ext_logmask_new (buf, sizeof (buf), NULL, 0, NULL);
+ len = qcdm_cmd_ext_logmask_new (buf, sizeof (buf), NULL, 0);
/* Send the command */
success = send_command (d, buf, len);
@@ -1279,19 +1270,16 @@ test_com_ext_logmask (void *f, void *data)
g_print ("\n");
/* Parse the response into a result structure */
- result = qcdm_cmd_ext_logmask_result (buf, reply_len, &error);
+ result = qcdm_cmd_ext_logmask_result (buf, reply_len, &err);
g_assert (result);
- qcdm_result_get_uint32 (result, QCDM_CMD_EXT_LOGMASK_ITEM_MAX_ITEMS, &maxlog);
+ qcdm_result_get_u32 (result, QCDM_CMD_EXT_LOGMASK_ITEM_MAX_ITEMS, &maxlog);
g_message ("%s: Max # Log Items: %u (0x%X)", __func__, maxlog, maxlog);
qcdm_result_unref (result);
/* Now enable some log items */
- items = g_slist_append (items, GUINT_TO_POINTER (0x002C));
- items = g_slist_append (items, GUINT_TO_POINTER (0x002E));
- len = qcdm_cmd_ext_logmask_new (buf, sizeof (buf), items, (guint16) maxlog, NULL);
- g_slist_free (items);
+ len = qcdm_cmd_ext_logmask_new (buf, sizeof (buf), items, (u_int16_t) maxlog);
/* Send the command */
success = send_command (d, buf, len);
@@ -1303,7 +1291,7 @@ test_com_ext_logmask (void *f, void *data)
g_print ("\n");
/* Parse the response into a result structure */
- result = qcdm_cmd_ext_logmask_result (buf, reply_len, &error);
+ result = qcdm_cmd_ext_logmask_result (buf, reply_len, &err);
g_assert (result);
qcdm_result_unref (result);
@@ -1317,14 +1305,14 @@ test_com_event_report (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[520];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
/* Turn event reporting on */
- len = qcdm_cmd_event_report_new (buf, sizeof (buf), TRUE, NULL);
+ len = qcdm_cmd_event_report_new (buf, sizeof (buf), TRUE);
/* Send the command */
success = send_command (d, buf, len);
@@ -1336,7 +1324,7 @@ test_com_event_report (void *f, void *data)
g_print ("\n");
/* Parse the response into a result structure */
- result = qcdm_cmd_event_report_result (buf, reply_len, &error);
+ result = qcdm_cmd_event_report_result (buf, reply_len, &err);
g_assert (result);
qcdm_result_unref (result);
@@ -1345,7 +1333,7 @@ test_com_event_report (void *f, void *data)
reply_len = wait_reply (d, buf, sizeof (buf));
/* Turn event reporting off */
- len = qcdm_cmd_event_report_new (buf, sizeof (buf), FALSE, NULL);
+ len = qcdm_cmd_event_report_new (buf, sizeof (buf), FALSE);
/* Send the command */
success = send_command (d, buf, len);
@@ -1360,14 +1348,14 @@ test_com_zte_subsys_status (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[100];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint8 ind = 0;
- len = qcdm_cmd_zte_subsys_status_new (buf, sizeof (buf), NULL);
+ len = qcdm_cmd_zte_subsys_status_new (buf, sizeof (buf));
g_assert (len == 7);
/* Send the command */
@@ -1380,16 +1368,16 @@ test_com_zte_subsys_status (void *f, void *data)
g_print ("\n");
/* Parse the response into a result structure */
- result = qcdm_cmd_zte_subsys_status_result (buf, reply_len, &error);
+ result = qcdm_cmd_zte_subsys_status_result (buf, reply_len, &err);
if (!result) {
/* Obviously not all devices implement this command */
- g_assert_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND);
+ g_assert_cmpint (err, ==, QCDM_ERROR_RESPONSE_BAD_COMMAND);
g_message ("%s: device does not implement the ZTE subsystem", __func__);
return;
}
g_assert (result);
- qcdm_result_get_uint8 (result, QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR, &ind);
+ qcdm_result_get_u8 (result, QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR, &ind);
g_message ("%s: Signal Indicator: %d", __func__, ind);
qcdm_result_unref (result);
@@ -1400,15 +1388,15 @@ test_com_nw_subsys_modem_snapshot_cdma (void *f, void *data)
{
TestComData *d = data;
gboolean success;
- GError *error = NULL;
+ int err = QCDM_SUCCESS;
char buf[200];
gint len;
- QCDMResult *result;
+ QcdmResult *result;
gsize reply_len;
guint8 num8 = 0;
guint32 num32 = 0;
- len = qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (buf, sizeof (buf), QCDM_NW_CHIPSET_6800, NULL);
+ len = qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (buf, sizeof (buf), QCDM_NW_CHIPSET_6800);
g_assert (len == 12);
/* Send the command */
@@ -1421,27 +1409,27 @@ test_com_nw_subsys_modem_snapshot_cdma (void *f, void *data)
g_print ("\n");
/* Parse the response into a result structure */
- result = qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (buf, reply_len, &error);
+ result = qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (buf, reply_len, &err);
if (!result) {
/* Obviously not all devices implement this command */
- g_assert_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND);
+ g_assert_cmpint (err, ==, QCDM_ERROR_RESPONSE_BAD_COMMAND);
return;
}
g_assert (result);
- qcdm_result_get_uint32 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI, &num32);
+ qcdm_result_get_u32 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI, &num32);
g_message ("%s: RSSI: %d", __func__, num32);
- qcdm_result_get_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV, &num8);
+ qcdm_result_get_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV, &num8);
g_message ("%s: P_REV: %s", __func__, prev_to_string (num8));
- qcdm_result_get_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS, &num8);
+ qcdm_result_get_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS, &num8);
g_message ("%s: Band Class: %s", __func__, band_class_to_string (num8));
- qcdm_result_get_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI, &num8);
+ qcdm_result_get_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI, &num8);
g_message ("%s: ERI: %d", __func__, num8);
- qcdm_result_get_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, &num8);
+ qcdm_result_get_u8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV, &num8);
g_message ("%s: HDR Revision: %s", __func__, hdr_rev_to_string (num8));
qcdm_result_unref (result);
diff --git a/libqcdm/tests/test-qcdm-escaping.c b/libqcdm/tests/test-qcdm-escaping.c
index fb5fb82a..0f403075 100644
--- a/libqcdm/tests/test-qcdm-escaping.c
+++ b/libqcdm/tests/test-qcdm-escaping.c
@@ -110,7 +110,7 @@ test_escape_unescape (void *f, void *data)
char escaped[512];
char unescaped[512];
gsize len, unlen;
- gboolean escaping = FALSE;
+ qcdmbool escaping = FALSE;
/* Ensure that escaping data that needs escaping, and then unescaping it,
* produces the exact same data as was originally escaped.
diff --git a/libqcdm/tests/test-qcdm-result.c b/libqcdm/tests/test-qcdm-result.c
index 87f264b0..0a1820dd 100644
--- a/libqcdm/tests/test-qcdm-result.c
+++ b/libqcdm/tests/test-qcdm-result.c
@@ -29,7 +29,7 @@ test_result_string (void *f, void *data)
{
const char *str = "foobarblahblahblah";
const char *tmp = NULL;
- QCDMResult *result;
+ QcdmResult *result;
result = qcdm_result_new ();
qcdm_result_add_string (result, TEST_TAG, str);
@@ -46,13 +46,13 @@ test_result_uint32 (void *f, void *data)
{
guint32 num = 0xDEADBEEF;
guint32 tmp = 0;
- QCDMResult *result;
+ QcdmResult *result;
result = qcdm_result_new ();
- qcdm_result_add_uint32 (result, TEST_TAG, num);
+ qcdm_result_add_u32 (result, TEST_TAG, num);
- qcdm_result_get_uint32 (result, TEST_TAG, &tmp);
- g_assert (tmp == num);
+ qcdm_result_get_u32 (result, TEST_TAG, &tmp);
+ g_assert_cmpint (tmp, ==, num);
}
void
@@ -60,12 +60,28 @@ test_result_uint8 (void *f, void *data)
{
guint8 num = 0x1E;
guint8 tmp = 0;
- QCDMResult *result;
+ QcdmResult *result;
result = qcdm_result_new ();
- qcdm_result_add_uint8 (result, TEST_TAG, num);
+ qcdm_result_add_u8 (result, TEST_TAG, num);
- qcdm_result_get_uint8 (result, TEST_TAG, &tmp);
+ qcdm_result_get_u8 (result, TEST_TAG, &tmp);
g_assert (tmp == num);
}
+void
+test_result_uint8_array (void *f, void *data)
+{
+ u_int8_t array[] = { 0, 1, 255, 32, 128, 127 };
+ const u_int8_t *tmp = NULL;
+ size_t tmp_len = 0;
+ QcdmResult *result;
+
+ result = qcdm_result_new ();
+ qcdm_result_add_u8_array (result, TEST_TAG, array, sizeof (array));
+
+ qcdm_result_get_u8_array (result, TEST_TAG, &tmp, &tmp_len);
+ g_assert_cmpint (tmp_len, ==, sizeof (array));
+ g_assert_cmpint (memcmp (tmp, array, tmp_len), ==, 0);
+}
+
diff --git a/libqcdm/tests/test-qcdm-result.h b/libqcdm/tests/test-qcdm-result.h
index 20d6cec0..3ab718b5 100644
--- a/libqcdm/tests/test-qcdm-result.h
+++ b/libqcdm/tests/test-qcdm-result.h
@@ -21,6 +21,7 @@
void test_result_string (void *f, void *data);
void test_result_uint32 (void *f, void *data);
void test_result_uint8 (void *f, void *data);
+void test_result_uint8_array (void *f, void *data);
#endif /* TEST_QCDM_RESULT_H */
diff --git a/libqcdm/tests/test-qcdm-utils.c b/libqcdm/tests/test-qcdm-utils.c
index 04807c16..4771838f 100644
--- a/libqcdm/tests/test-qcdm-utils.c
+++ b/libqcdm/tests/test-qcdm-utils.c
@@ -50,7 +50,7 @@ test_utils_decapsulate_buffer (void *f, void *data)
char outbuf[512];
gsize decap_len = 0;
gsize used = 0;
- gboolean more = FALSE;
+ qcdmbool more = FALSE;
success = dm_decapsulate_buffer (decap_inbuf, sizeof (decap_inbuf),
outbuf, sizeof (outbuf),
@@ -96,7 +96,7 @@ test_utils_decapsulate_sierra_cns (void *f, void *data)
char outbuf[512];
gsize decap_len = 0;
gsize used = 0;
- gboolean more = FALSE;
+ qcdmbool more = FALSE;
success = dm_decapsulate_buffer (cns_inbuf, sizeof (cns_inbuf),
outbuf, sizeof (outbuf),
diff --git a/libqcdm/tests/test-qcdm.c b/libqcdm/tests/test-qcdm.c
index 946fb673..6cc32fbe 100644
--- a/libqcdm/tests/test-qcdm.c
+++ b/libqcdm/tests/test-qcdm.c
@@ -93,6 +93,7 @@ int main (int argc, char **argv)
g_test_suite_add (suite, TESTCASE (test_result_string, NULL));
g_test_suite_add (suite, TESTCASE (test_result_uint32, NULL));
g_test_suite_add (suite, TESTCASE (test_result_uint8, NULL));
+ g_test_suite_add (suite, TESTCASE (test_result_uint8_array, NULL));
/* Live tests */
if (port) {
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-21 19:11:35 +0000