SymbX/ModemManager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

qcdm: remove usage of glib

Browse Source 
People have asked for this at various times.
This commit is contained in:
Dan Williams
2012-01-03 00:21:05 -06:00
parent 1e1c8a5ae4
commit 7b14063f46
23 changed files with 1391 additions and 1286 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libqcdm/configure.ac
+2 -3
View File
@@ -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
libqcdm/src/Makefile.am
+2 -2
View File
@@ -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 \
libqcdm/src/com.c
+8 -13
View File
@@ -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;
}
libqcdm/src/com.h
+2 -2
View File
@@ -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 */
libqcdm/src/commands.c
+414 -424
View File
File diff suppressed because it is too large Load Diff
libqcdm/src/commands.h
+106 -138
View File
@@ -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);
/**********************************************************************/
libqcdm/src/dm-commands.h
+125 -125
View File
@@ -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;
libqcdm/src/error.c
-88
View File
@@ -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;
}
libqcdm/src/error.h
-54
View File
@@ -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 */
libqcdm/src/errors.c
+60
View File
@@ -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);
}
}
libqcdm/src/errors.h
+94
View File
@@ -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 */
libqcdm/src/nv-items.h
+9 -7
View File
@@ -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;
libqcdm/src/result-private.h
+17 -20
View File
@@ -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,
void qcdm_result_add_u8_array (QcdmResult *result,
const char *key,
const u_int8_t *array,
size_t array_len);
int qcdm_result_get_u8_array (QcdmResult *result,
const char *key,
const u_int8_t **out_val,
size_t *out_len);
void qcdm_result_add_u32 (QcdmResult *result,
const char *key,
guint32 num);
void qcdm_result_add_boxed (QCDMResult *result,
const char *key,
GType btype,
gpointer boxed);
gboolean qcdm_result_get_boxed (QCDMResult *result,
const char *key,
gpointer *out_val);
u_int32_t num);
#endif /* LIBQCDM_RESULT_PRIVATE_H */
libqcdm/src/result.c
+308 -182
View File
@@ -16,233 +16,359 @@
*/
#include <string.h>
#include <glib.h>
#include <stdlib.h>
#include "result.h"
#include "result-private.h"
#include "error.h"
#include "errors.h"
struct QCDMResult {
guint32 refcount;
GHashTable *hash;
/*********************************************************/
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 *
static Val *
val_new_string (const char *key, const char *value)
{
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);
v = calloc (sizeof (Val), 1);
if (v == NULL)
return NULL;
v->key = strdup (key);
v->type = VAL_TYPE_STRING;
v->u.s = strdup (value);
return v;
}
static Val *
val_new_u8 (const char *key, u_int8_t u)
{
Val *v;
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;
}
static Val *
val_new_u8_array (const char *key, const u_int8_t *array, size_t array_len)
{
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;
}
static Val *
val_new_u32 (const char *key, u_int32_t u)
{
Val *v;
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_U32;
v->u.u32 = u;
return v;
}
/*********************************************************/
struct QcdmResult {
u_int32_t refcount;
Val *first;
};
QcdmResult *
qcdm_result_new (void)
{
QCDMResult *result;
QcdmResult *r;
g_type_init ();
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;
r = calloc (sizeof (QcdmResult), 1);
if (r)
r->refcount = 1;
return r;
}
QCDMResult *
qcdm_result_ref (QCDMResult *result)
QcdmResult *
qcdm_result_ref (QcdmResult *r)
{
g_return_val_if_fail (result != NULL, NULL);
g_return_val_if_fail (result->refcount > 0, NULL);
qcdm_return_val_if_fail (r != NULL, NULL);
qcdm_return_val_if_fail (r->refcount > 0, NULL);
result->refcount++;
return result;
r->refcount++;
return r;
}
void
qcdm_result_unref (QCDMResult *result)
static void
qcdm_result_free (QcdmResult *r)
{
g_return_if_fail (result != NULL);
g_return_if_fail (result->refcount > 0);
Val *v, *n;
result->refcount--;
if (result->refcount == 0) {
g_hash_table_destroy (result->hash);
memset (result, 0, sizeof (QCDMResult));
g_free (result);
v = r->first;
while (v) {
n = v->next;
val_free (v);
v = n;
}
memset (r, 0, sizeof (*r));
free (r);
}
void
qcdm_result_add_string (QCDMResult *result,
const char *key,
const char *str)
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);
g_return_if_fail (str != NULL);
val = g_slice_new0 (GValue);
g_value_init (val, G_TYPE_STRING);
g_value_set_string (val, str);
g_hash_table_insert (result->hash, (gpointer) key, val);
r->refcount--;
if (r->refcount == 0)
qcdm_result_free (r);
}
gboolean
qcdm_result_get_string (QCDMResult *result,
const char *key,
const char **out_val)
static Val *
find_val (QcdmResult *r, const char *key, ValType expected_type)
{
GValue *val;
Val *v, *n;
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);
val = g_hash_table_lookup (result->hash, key);
if (!val)
return FALSE;
g_warn_if_fail (G_VALUE_HOLDS_STRING (val));
if (!G_VALUE_HOLDS_STRING (val))
return FALSE;
*out_val = g_value_get_string (val);
return TRUE;
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;
}
void
qcdm_result_add_uint8 (QCDMResult *result,
const char *key,
guint8 num)
{
GValue *val;
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);
g_hash_table_insert (result->hash, (gpointer) key, val);
}
gboolean
qcdm_result_get_uint8 (QCDMResult *result,
const char *key,
guint8 *out_val)
{
GValue *val;
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);
val = g_hash_table_lookup (result->hash, key);
if (!val)
return FALSE;
g_warn_if_fail (G_VALUE_HOLDS_UCHAR (val));
if (!G_VALUE_HOLDS_UCHAR (val))
return FALSE;
*out_val = (guint8) g_value_get_uchar (val);
return TRUE;
}
void
qcdm_result_add_uint32 (QCDMResult *result,
const char *key,
guint32 num)
{
GValue *val;
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_UINT);
g_value_set_uint (val, num);
g_hash_table_insert (result->hash, (gpointer) key, val);
}
gboolean
qcdm_result_get_uint32 (QCDMResult *result,
const char *key,
guint32 *out_val)
{
GValue *val;
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);
val = g_hash_table_lookup (result->hash, key);
if (!val)
return FALSE;
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;
}
void
qcdm_result_add_boxed (QCDMResult *result,
qcdm_result_add_string (QcdmResult *r,
const char *key,
GType btype,
gpointer boxed)
const char *str)
{
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_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_slice_new0 (GValue);
g_value_init (val, btype);
g_value_set_static_boxed (val, boxed);
g_hash_table_insert (result->hash, (gpointer) key, val);
v = val_new_string (key, str);
qcdm_return_if_fail (v != NULL);
v->next = r->first;
r->first = v;
}
gboolean
qcdm_result_get_boxed (QCDMResult *result,
int
qcdm_result_get_string (QcdmResult *r,
const char *key,
gpointer *out_val)
const char **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);
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_STRING);
if (v == NULL)
return -QCDM_ERROR_VALUE_NOT_FOUND;
g_warn_if_fail (G_VALUE_HOLDS_BOXED (val));
if (!G_VALUE_HOLDS_BOXED (val))
return FALSE;
*out_val = v->u.s;
return 0;
}
*out_val = g_value_get_boxed (val);
return TRUE;
void
qcdm_result_add_u8 (QcdmResult *r,
const char *key,
u_int8_t num)
{
Val *v;
qcdm_return_if_fail (r != NULL);
qcdm_return_if_fail (r->refcount > 0);
qcdm_return_if_fail (key != NULL);
v = val_new_u8 (key, num);
qcdm_return_if_fail (v != NULL);
v->next = r->first;
r->first = v;
}
int
qcdm_result_get_u8 (QcdmResult *r,
const char *key,
u_int8_t *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);
v = find_val (r, key, VAL_TYPE_U8);
if (v == NULL)
return -QCDM_ERROR_VALUE_NOT_FOUND;
*out_val = v->u.u8;
return 0;
}
void
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)
{
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_len != NULL, -QCDM_ERROR_INVALID_ARGUMENTS);
v = find_val (r, key, VAL_TYPE_U8_ARRAY);
if (v == NULL)
return -QCDM_ERROR_VALUE_NOT_FOUND;
*out_val = v->u.u8_array;
*out_len = v->array_len;
return 0;
}
void
qcdm_result_add_u32 (QcdmResult *r,
const char *key,
u_int32_t num)
{
Val *v;
qcdm_return_if_fail (r != NULL);
qcdm_return_if_fail (r->refcount > 0);
qcdm_return_if_fail (key != NULL);
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;
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);
v = find_val (r, key, VAL_TYPE_U32);
if (v == NULL)
return -QCDM_ERROR_VALUE_NOT_FOUND;
*out_val = v->u.u32;
return 0;
}
libqcdm/src/result.h
+13 -13
View File
@@ -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 */
libqcdm/src/utils.c
+45 -44
View File
@@ -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;
qcdmbool escaping = FALSE;
size_t i, pkt_len = 0, unesc_len;
u_int16_t 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);
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;
libqcdm/src/utils.h
+31 -22
View File
@@ -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 */
libqcdm/tests/test-qcdm-com.c
+126 -138
View File
@@ -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);
libqcdm/tests/test-qcdm-escaping.c
+1 -1
View File
@@ -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.
libqcdm/tests/test-qcdm-result.c
+24 -8
View File
@@ -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);
}
libqcdm/tests/test-qcdm-result.h
+1
View File
@@ -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 */
libqcdm/tests/test-qcdm-utils.c
+2 -2
View File
@@ -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),
libqcdm/tests/test-qcdm.c
+1
View File
@@ -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) {