diff options
Diffstat (limited to 'libqcdm/src')
-rw-r--r-- | libqcdm/src/Makefile.am | 42 | ||||
-rw-r--r-- | libqcdm/src/com.c | 61 | ||||
-rw-r--r-- | libqcdm/src/com.h | 25 | ||||
-rw-r--r-- | libqcdm/src/commands.c | 1064 | ||||
-rw-r--r-- | libqcdm/src/commands.h | 437 | ||||
-rw-r--r-- | libqcdm/src/dm-commands.h | 370 | ||||
-rw-r--r-- | libqcdm/src/error.c | 87 | ||||
-rw-r--r-- | libqcdm/src/error.h | 53 | ||||
-rw-r--r-- | libqcdm/src/libqcdm.ver | 6 | ||||
-rw-r--r-- | libqcdm/src/nv-items.h | 64 | ||||
-rw-r--r-- | libqcdm/src/result-private.h | 51 | ||||
-rw-r--r-- | libqcdm/src/result.c | 248 | ||||
-rw-r--r-- | libqcdm/src/result.h | 42 | ||||
-rw-r--r-- | libqcdm/src/utils.c | 311 | ||||
-rw-r--r-- | libqcdm/src/utils.h | 54 |
15 files changed, 2915 insertions, 0 deletions
diff --git a/libqcdm/src/Makefile.am b/libqcdm/src/Makefile.am new file mode 100644 index 0000000..5cc0568 --- /dev/null +++ b/libqcdm/src/Makefile.am @@ -0,0 +1,42 @@ +noinst_LTLIBRARIES = libqcdm.la libqcdm-test.la + + +libqcdm_la_CPPFLAGS = \ + $(MM_CFLAGS) + +libqcdm_la_SOURCES = \ + dm-commands.h \ + nv-items.h \ + com.c \ + com.h \ + commands.c \ + commands.h \ + error.c \ + error.h \ + result.c \ + result.h \ + result-private.h \ + utils.c \ + utils.h + +libqcdm_la_LIBADD = \ + $(MM_LIBS) + +libqcdm_la_LDFLAGS = -Wl,--version-script=$(srcdir)/libqcdm.ver \ + -version-info "0:0:0" + + +########################################### +# Test library without symbol versioning +########################################### + +libqcdm_test_la_CPPFLAGS = \ + $(MM_CFLAGS) + +libqcdm_test_la_SOURCES = \ + utils.c \ + utils.h + +libqcdm_test_la_LIBADD = \ + $(MM_LIBS) + diff --git a/libqcdm/src/com.c b/libqcdm/src/com.c new file mode 100644 index 0000000..353103a --- /dev/null +++ b/libqcdm/src/com.c @@ -0,0 +1,61 @@ +/* -*- 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 <errno.h> +#include <termios.h> +#include <fcntl.h> +#include <string.h> + +#include "com.h" +#include "error.h" + +gboolean +qcdm_port_setup (int fd, GError **error) +{ + 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); + } + + stbuf.c_cflag &= ~(CBAUD | CSIZE | CSTOPB | CLOCAL | PARENB); + stbuf.c_iflag &= ~(HUPCL | IUTF8 | IUCLC | ISTRIP | IXON | IXOFF | IXANY | ICRNL); + stbuf.c_oflag &= ~(OPOST | OCRNL | ONLCR | OLCUC | ONLRET); + stbuf.c_lflag &= ~(ICANON | ISIG | IEXTEN | ECHO | ECHOE | ECHOK | ECHONL); + stbuf.c_lflag &= ~(NOFLSH | XCASE | TOSTOP | ECHOPRT | ECHOCTL | ECHOKE); + stbuf.c_cc[VMIN] = 1; + stbuf.c_cc[VTIME] = 0; + stbuf.c_cc[VEOF] = 1; + stbuf.c_cflag |= (B115200 | CS8 | CREAD | 0 | 0); /* No parity, 1 stop bit */ + + 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; + } + + return TRUE; +} + diff --git a/libqcdm/src/com.h b/libqcdm/src/com.h new file mode 100644 index 0000000..97561d0 --- /dev/null +++ b/libqcdm/src/com.h @@ -0,0 +1,25 @@ +/* -*- 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_COM_H +#define LIBQCDM_COM_H + +#include <glib.h> + +gboolean qcdm_port_setup (int fd, GError **error); + +#endif /* LIBQCDM_COM_H */ diff --git a/libqcdm/src/commands.c b/libqcdm/src/commands.c new file mode 100644 index 0000000..11a1a38 --- /dev/null +++ b/libqcdm/src/commands.c @@ -0,0 +1,1064 @@ +/* -*- 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 <string.h> + +#include "commands.h" +#include "error.h" +#include "dm-commands.h" +#include "nv-items.h" +#include "result-private.h" +#include "utils.h" + + +/**********************************************************************/ + +static guint8 +cdma_prev_to_qcdm (guint8 cdma) +{ + switch (cdma) { + case CDMA_PREV_IS_95: + return QCDM_CDMA_PREV_IS_95; + case CDMA_PREV_IS_95A: + return QCDM_CDMA_PREV_IS_95A; + case CDMA_PREV_IS_95A_TSB74: + return QCDM_CDMA_PREV_IS_95A_TSB74; + case CDMA_PREV_IS_95B_PHASE1: + return QCDM_CDMA_PREV_IS_95B_PHASE1; + case CDMA_PREV_IS_95B_PHASE2: + return QCDM_CDMA_PREV_IS_95B_PHASE2; + case CDMA_PREV_IS2000_REL0: + return QCDM_CDMA_PREV_IS2000_REL0; + case CDMA_PREV_IS2000_RELA: + return QCDM_CDMA_PREV_IS2000_RELA; + default: + break; + } + return QCDM_CDMA_PREV_UNKNOWN; +} + +static guint8 +cdma_band_class_to_qcdm (guint8 cdma) +{ + switch (cdma) { + case CDMA_BAND_CLASS_0_CELLULAR_800: + return QCDM_CDMA_BAND_CLASS_0_CELLULAR_800; + case CDMA_BAND_CLASS_1_PCS: + return QCDM_CDMA_BAND_CLASS_1_PCS; + case CDMA_BAND_CLASS_2_TACS: + return QCDM_CDMA_BAND_CLASS_2_TACS; + case CDMA_BAND_CLASS_3_JTACS: + return QCDM_CDMA_BAND_CLASS_3_JTACS; + case CDMA_BAND_CLASS_4_KOREAN_PCS: + return QCDM_CDMA_BAND_CLASS_4_KOREAN_PCS; + case CDMA_BAND_CLASS_5_NMT450: + return QCDM_CDMA_BAND_CLASS_5_NMT450; + case CDMA_BAND_CLASS_6_IMT2000: + return QCDM_CDMA_BAND_CLASS_6_IMT2000; + case CDMA_BAND_CLASS_7_CELLULAR_700: + return QCDM_CDMA_BAND_CLASS_7_CELLULAR_700; + case CDMA_BAND_CLASS_8_1800: + return QCDM_CDMA_BAND_CLASS_8_1800; + case CDMA_BAND_CLASS_9_900: + return QCDM_CDMA_BAND_CLASS_9_900; + case CDMA_BAND_CLASS_10_SECONDARY_800: + return QCDM_CDMA_BAND_CLASS_10_SECONDARY_800; + case CDMA_BAND_CLASS_11_PAMR_400: + return QCDM_CDMA_BAND_CLASS_11_PAMR_400; + case CDMA_BAND_CLASS_12_PAMR_800: + return QCDM_CDMA_BAND_CLASS_12_PAMR_800; + default: + break; + } + return QCDM_CDMA_BAND_CLASS_UNKNOWN; +} + +/**********************************************************************/ + +/* + * utils_bin2hexstr + * + * Convert a byte-array into a hexadecimal string. + * + * Code originally by Alex Larsson <alexl@redhat.com> and + * copyright Red Hat, Inc. under terms of the LGPL. + * + */ +static char * +bin2hexstr (const guint8 *bytes, int len) +{ + static char hex_digits[] = "0123456789abcdef"; + char *result; + int i; + gsize 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 */ + + 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]; + } + result[buflen - 1] = '\0'; + return result; +} + +static gboolean +check_command (const char *buf, gsize len, guint8 cmd, gsize min_len, GError **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)"); + 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); + 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); + 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); + 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); + 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); + 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]); + 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); + return FALSE; + } + + return TRUE; +} + +static gboolean +check_nv_cmd (DMCmdNVReadWrite *cmd, guint16 nv_item, GError **error) +{ + guint16 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); + + /* 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)); + return FALSE; + } + + cmd_item = GUINT16_FROM_LE (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); + return FALSE; + } + + return TRUE; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_version_info_new (char *buf, gsize len, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_VERSION_INFO; + + 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 *result = NULL; + DMCmdVersionInfoRsp *rsp = (DMCmdVersionInfoRsp *) buf; + char tmp[12]; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_VERSION_INFO, sizeof (DMCmdVersionInfoRsp), error)) + return NULL; + + result = qcdm_result_new (); + + memset (tmp, 0, sizeof (tmp)); + g_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)); + 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)); + 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)); + 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)); + memcpy (tmp, rsp->model, sizeof (rsp->model)); + qcdm_result_add_string (result, QCDM_CMD_VERSION_INFO_ITEM_MODEL, tmp); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_esn_new (char *buf, gsize len, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_ESN; + + return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len); +} + +QCDMResult * +qcdm_cmd_esn_result (const char *buf, gsize len, GError **error) +{ + QCDMResult *result = NULL; + DMCmdEsnRsp *rsp = (DMCmdEsnRsp *) buf; + char *tmp; + guint8 swapped[4]; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_ESN, sizeof (DMCmdEsnRsp), 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. + */ + swapped[0] = rsp->esn[3]; + swapped[1] = rsp->esn[2]; + swapped[2] = rsp->esn[1]; + 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); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_cdma_status_new (char *buf, gsize len, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_STATUS; + + 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 *result = NULL; + DMCmdStatusRsp *rsp = (DMCmdStatusRsp *) buf; + char *tmp; + guint8 swapped[4]; + guint32 tmp_num; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_STATUS, sizeof (DMCmdStatusRsp), 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. + */ + swapped[0] = rsp->esn[3]; + swapped[1] = rsp->esn[2]; + swapped[2] = rsp->esn[1]; + swapped[3] = rsp->esn[0]; + + tmp = bin2hexstr (&swapped[0], sizeof (swapped)); + qcdm_result_add_string (result, QCDM_CMD_CDMA_STATUS_ITEM_ESN, tmp); + g_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 = (guint32) GUINT16_FROM_LE (rsp->cdma_rx_state); + qcdm_result_add_uint32 (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 = (guint32) GUINT16_FROM_LE (rsp->curr_chan); + qcdm_result_add_uint32 (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); + + 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 = (guint32) GUINT16_FROM_LE (rsp->sid); + qcdm_result_add_uint32 (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); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_sw_version_new (char *buf, gsize len, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_SW_VERSION; + + 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 *result = NULL; + DMCmdSwVersionRsp *rsp = (DMCmdSwVersionRsp *) buf; + char tmp[25]; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_SW_VERSION, sizeof (*rsp), error)) + return NULL; + + result = qcdm_result_new (); + + memset (tmp, 0, sizeof (tmp)); + g_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)); + 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)); + memcpy (tmp, rsp->comp_time, sizeof (rsp->comp_time)); + qcdm_result_add_string (result, QCDM_CMD_SW_VERSION_ITEM_COMP_TIME, tmp); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_pilot_sets_new (char *buf, gsize len, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_PILOT_SETS; + + return dm_encapsulate_buffer (cmdbuf, sizeof (*cmd), sizeof (cmdbuf), buf, len); +} + +#define PILOT_SETS_CMD_ACTIVE_SET "active-set" +#define PILOT_SETS_CMD_CANDIDATE_SET "candidate-set" +#define PILOT_SETS_CMD_NEIGHBOR_SET "neighbor-set" + +static const char * +set_num_to_str (guint32 num) +{ + if (num == QCDM_CMD_PILOT_SETS_TYPE_ACTIVE) + return PILOT_SETS_CMD_ACTIVE_SET; + if (num == QCDM_CMD_PILOT_SETS_TYPE_CANDIDATE) + return PILOT_SETS_CMD_CANDIDATE_SET; + if (num == QCDM_CMD_PILOT_SETS_TYPE_NEIGHBOR) + return PILOT_SETS_CMD_NEIGHBOR_SET; + return NULL; +} + +QCDMResult * +qcdm_cmd_pilot_sets_result (const char *buf, gsize len, GError **error) +{ + QCDMResult *result = NULL; + DMCmdPilotSetsRsp *rsp = (DMCmdPilotSetsRsp *) buf; + GByteArray *array; + gsize sets_len; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_PILOT_SETS, sizeof (DMCmdPilotSetsRsp), 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); + } + + 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); + } + + 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); + } + + return result; +} + +gboolean +qcdm_cmd_pilot_sets_result_get_num (QCDMResult *result, + guint32 set_type, + guint32 *out_num) +{ + const char *set_name; + GByteArray *array = NULL; + + g_return_val_if_fail (result != NULL, FALSE); + + set_name = set_num_to_str (set_type); + g_return_val_if_fail (set_name != NULL, FALSE); + + if (!qcdm_result_get_boxed (result, set_name, (gpointer) &array)) + return FALSE; + + *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, + float *out_db) +{ + const char *set_name; + GByteArray *array = NULL; + DMCmdPilotSetsSet *set; + + g_return_val_if_fail (result != NULL, FALSE); + + set_name = set_num_to_str (set_type); + g_return_val_if_fail (set_name != NULL, FALSE); + + if (!qcdm_result_get_boxed (result, set_name, (gpointer) &array)) + return FALSE; + + g_return_val_if_fail (num < array->len / sizeof (DMCmdPilotSetsSet), FALSE); + + set = (DMCmdPilotSetsSet *) &array->data[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 */ + *out_db = (float) set->ecio * -0.5; + return TRUE; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_nv_get_mdn_new (char *buf, gsize len, guint8 profile, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_NV_READ; + cmd->nv_item = GUINT16_TO_LE (DIAG_NV_DIR_NUMBER); + + req = (DMNVItemMdn *) &cmd->data[0]; + req->profile = profile; + + 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 *result = NULL; + DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf; + DMNVItemMdn *mdn; + char tmp[11]; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error)) + return NULL; + + if (!check_nv_cmd (rsp, DIAG_NV_DIR_NUMBER, 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); + + memset (tmp, 0, sizeof (tmp)); + g_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); + + return result; +} + +/**********************************************************************/ + +static gboolean +roam_pref_validate (guint8 dm) +{ + if ( dm == DIAG_NV_ROAM_PREF_HOME_ONLY + || dm == DIAG_NV_ROAM_PREF_ROAM_ONLY + || dm == DIAG_NV_ROAM_PREF_AUTO) + return TRUE; + return FALSE; +} + +gsize +qcdm_cmd_nv_get_roam_pref_new (char *buf, gsize len, guint8 profile, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_NV_READ; + cmd->nv_item = GUINT16_TO_LE (DIAG_NV_ROAM_PREF); + + req = (DMNVItemRoamPref *) &cmd->data[0]; + req->profile = profile; + + 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 *result = NULL; + DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf; + DMNVItemRoamPref *roam; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error)) + return NULL; + + if (!check_nv_cmd (rsp, DIAG_NV_ROAM_PREF, 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); + 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); + + return result; +} + +gsize +qcdm_cmd_nv_set_roam_pref_new (char *buf, + gsize len, + guint8 profile, + guint8 roam_pref, + GError **error) +{ + 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); + + if (!roam_pref_validate (roam_pref)) { + g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER, + "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); + + req = (DMNVItemRoamPref *) &cmd->data[0]; + req->profile = profile; + req->roam_pref = roam_pref; + + 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) +{ + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error)) + return NULL; + + if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_ROAM_PREF, error)) + return NULL; + + return qcdm_result_new (); +} + +/**********************************************************************/ + +static gboolean +mode_pref_validate (guint8 dm) +{ + if ( dm == DIAG_NV_MODE_PREF_1X_ONLY + || dm == DIAG_NV_MODE_PREF_HDR_ONLY + || dm == DIAG_NV_MODE_PREF_AUTO) + return TRUE; + return FALSE; +} + +gsize +qcdm_cmd_nv_get_mode_pref_new (char *buf, gsize len, guint8 profile, GError **error) +{ + 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); + + memset (cmd, 0, sizeof (*cmd)); + cmd->code = DIAG_CMD_NV_READ; + cmd->nv_item = GUINT16_TO_LE (DIAG_NV_MODE_PREF); + + req = (DMNVItemModePref *) &cmd->data[0]; + req->profile = profile; + + 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 *result = NULL; + DMCmdNVReadWrite *rsp = (DMCmdNVReadWrite *) buf; + DMNVItemModePref *mode; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_NV_READ, sizeof (DMCmdNVReadWrite), error)) + return NULL; + + if (!check_nv_cmd (rsp, DIAG_NV_MODE_PREF, 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); + 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); + + return result; +} + +gsize +qcdm_cmd_nv_set_mode_pref_new (char *buf, + gsize len, + guint8 profile, + guint8 mode_pref, + GError **error) +{ + 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); + + if (!mode_pref_validate (mode_pref)) { + g_set_error (error, QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_PARAMETER, + "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); + + req = (DMNVItemModePref *) &cmd->data[0]; + req->profile = profile; + req->mode_pref = mode_pref; + + 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) +{ + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_NV_WRITE, sizeof (DMCmdNVReadWrite), error)) + return NULL; + + if (!check_nv_cmd ((DMCmdNVReadWrite *) buf, DIAG_NV_MODE_PREF, error)) + return NULL; + + return qcdm_result_new (); +} + +/**********************************************************************/ + +gsize +qcdm_cmd_cm_subsys_state_info_new (char *buf, gsize len, GError **error) +{ + 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); + + 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); + + 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 *result = NULL; + DMCmdSubsysCMStateInfoRsp *rsp = (DMCmdSubsysCMStateInfoRsp *) buf; + guint32 tmp_num; + guint32 roam_pref; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysCMStateInfoRsp), error)) + return NULL; + + roam_pref = (guint32) GUINT32_FROM_LE (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); + 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 = (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 = (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 = (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 = (guint32) GUINT32_FROM_LE (rsp->band_pref); + qcdm_result_add_uint32 (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); + + 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 = (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 = (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 = (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); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_hdr_subsys_state_info_new (char *buf, gsize len, GError **error) +{ + 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); + + 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); + + 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 *result = NULL; + DMCmdSubsysHDRStateInfoRsp *rsp = (DMCmdSubsysHDRStateInfoRsp *) buf; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysHDRStateInfoRsp), 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); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_zte_subsys_status_new (char *buf, gsize len, GError **error) +{ + 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); + + 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); + + 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 *result = NULL; + DMCmdSubsysZteStatusRsp *rsp = (DMCmdSubsysZteStatusRsp *) buf; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysZteStatusRsp), error)) + return NULL; + + result = qcdm_result_new (); + + qcdm_result_add_uint8 (result, QCDM_CMD_ZTE_SUBSYS_STATUS_ITEM_SIGNAL_INDICATOR, rsp->signal_ind); + + return result; +} + +/**********************************************************************/ + +gsize +qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf, + gsize len, + guint8 chipset, + GError **error) +{ + 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); + + /* 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); + return 0; + } + + memset (cmd, 0, sizeof (*cmd)); + cmd->hdr.code = DIAG_CMD_SUBSYS; + switch (chipset) { + case QCDM_NW_CHIPSET_6500: + cmd->hdr.subsys_id = DIAG_SUBSYS_NW_CONTROL_6500; + break; + case QCDM_NW_CHIPSET_6800: + cmd->hdr.subsys_id = DIAG_SUBSYS_NW_CONTROL_6800; + break; + default: + g_assert_not_reached (); + } + cmd->hdr.subsys_cmd = GUINT16_TO_LE (DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT); + cmd->technology = DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_CDMA_EVDO; + cmd->snapshot_mask = GUINT32_TO_LE (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 *result = NULL; + DMCmdSubsysNwSnapshotRsp *rsp = (DMCmdSubsysNwSnapshotRsp *) buf; + DMCmdSubsysNwSnapshotCdma *cdma = (DMCmdSubsysNwSnapshotCdma *) &rsp->data; + guint32 num; + guint8 num8; + + g_return_val_if_fail (buf != NULL, NULL); + + if (!check_command (buf, len, DIAG_CMD_SUBSYS, sizeof (DMCmdSubsysNwSnapshotRsp), 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); + + num8 = cdma_prev_to_qcdm (cdma->prev); + qcdm_result_add_uint8 (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_uint8 (result, QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI, cdma->eri); + + num8 = QCDM_HDR_REV_UNKNOWN; + switch (cdma->hdr_rev) { + case 0: + num8 = QCDM_HDR_REV_0; + break; + case 1: + num8 = QCDM_HDR_REV_A; + break; + default: + break; + } + qcdm_result_add_uint8 (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 new file mode 100644 index 0000000..75e83a7 --- /dev/null +++ b/libqcdm/src/commands.h @@ -0,0 +1,437 @@ +/* -*- 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_COMMANDS_H +#define LIBQCDM_COMMANDS_H + +#include <glib.h> + +#include "result.h" + +/**********************************************************************/ + +/* Generic enums */ + +enum { + QCDM_CDMA_PREV_UNKNOWN = 0, + QCDM_CDMA_PREV_IS_95 = 1, /* and J_STD008 */ + QCDM_CDMA_PREV_IS_95A = 2, + QCDM_CDMA_PREV_IS_95A_TSB74 = 3, + QCDM_CDMA_PREV_IS_95B_PHASE1 = 4, + QCDM_CDMA_PREV_IS_95B_PHASE2 = 5, + QCDM_CDMA_PREV_IS2000_REL0 = 6, + QCDM_CDMA_PREV_IS2000_RELA = 7 +}; + +enum { + QCDM_CDMA_BAND_CLASS_UNKNOWN = 0, + QCDM_CDMA_BAND_CLASS_0_CELLULAR_800 = 1, /* US cellular 850MHz */ + QCDM_CDMA_BAND_CLASS_1_PCS = 2, /* US PCS 1900MHz */ + QCDM_CDMA_BAND_CLASS_2_TACS = 3, + QCDM_CDMA_BAND_CLASS_3_JTACS = 4, /* Japanese TACS */ + QCDM_CDMA_BAND_CLASS_4_KOREAN_PCS = 5, + QCDM_CDMA_BAND_CLASS_5_NMT450 = 6, + QCDM_CDMA_BAND_CLASS_6_IMT2000 = 7, /* 2100HMz */ + QCDM_CDMA_BAND_CLASS_7_CELLULAR_700 = 8, + QCDM_CDMA_BAND_CLASS_8_1800 = 9, + QCDM_CDMA_BAND_CLASS_9_900 = 10, + QCDM_CDMA_BAND_CLASS_10_SECONDARY_800 = 11, + QCDM_CDMA_BAND_CLASS_11_PAMR_400 = 12, + QCDM_CDMA_BAND_CLASS_12_PAMR_800 = 13 +}; + +enum { + QCDM_HDR_REV_UNKNOWN = 0x00, + QCDM_HDR_REV_0 = 0x01, + QCDM_HDR_REV_A = 0x02 +}; + +/**********************************************************************/ + +#define QCDM_CMD_VERSION_INFO_ITEM_COMP_DATE "comp-date" +#define QCDM_CMD_VERSION_INFO_ITEM_COMP_TIME "comp-time" +#define QCDM_CMD_VERSION_INFO_ITEM_RELEASE_DATE "release-date" +#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); + +QCDMResult *qcdm_cmd_version_info_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +#define QCDM_CMD_ESN_ITEM_ESN "esn" + +gsize qcdm_cmd_esn_new (char *buf, + gsize len, + GError **error); + +QCDMResult *qcdm_cmd_esn_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +/* Values for QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE */ +enum { + QCDM_CMD_CDMA_STATUS_RF_MODE_ANALOG = 0, + QCDM_CMD_CDMA_STATUS_RF_MODE_CDMA_CELLULAR = 1, + QCDM_CMD_CDMA_STATUS_RF_MODE_CDMA_PCS = 2, + QCDM_CMD_CDMA_STATUS_RF_MODE_SLEEP = 3, + QCDM_CMD_CDMA_STATUS_RF_MODE_GPS = 4, + QCDM_CMD_CDMA_STATUS_RF_MODE_HDR = 5, +}; + +/* Values for QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE */ +enum { + QCDM_CMD_CDMA_STATUS_RX_STATE_ENTERING_CDMA = 0, + QCDM_CMD_CDMA_STATUS_RX_STATE_SYNC_CHANNEL = 1, + QCDM_CMD_CDMA_STATUS_RX_STATE_PAGING_CHANNEL = 2, + QCDM_CMD_CDMA_STATUS_RX_STATE_TRAFFIC_CHANNEL_INIT = 3, + QCDM_CMD_CDMA_STATUS_RX_STATE_TRAFFIC_CHANNEL = 4, + QCDM_CMD_CDMA_STATUS_RX_STATE_EXITING_CDMA = 5, +}; + +#define QCDM_CMD_CDMA_STATUS_ITEM_ESN "esn" +#define QCDM_CMD_CDMA_STATUS_ITEM_RF_MODE "rf-mode" +#define QCDM_CMD_CDMA_STATUS_ITEM_RX_STATE "rx-state" +#define QCDM_CMD_CDMA_STATUS_ITEM_ENTRY_REASON "entry-reason" +#define QCDM_CMD_CDMA_STATUS_ITEM_CURRENT_CHANNEL "current-channel" +#define QCDM_CMD_CDMA_STATUS_ITEM_CODE_CHANNEL "code-channel" +#define QCDM_CMD_CDMA_STATUS_ITEM_PILOT_BASE "pilot-base" +#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); + +QCDMResult *qcdm_cmd_cdma_status_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +/* NOTE: this command does not appear to be implemented in recent + * devices and probably returns (QCDM_COMMAND_ERROR, QCDM_COMMAND_BAD_COMMAND). + */ + +#define QCDM_CMD_SW_VERSION_ITEM_VERSION "version" +#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); + +QCDMResult *qcdm_cmd_sw_version_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +enum { + QCDM_CMD_PILOT_SETS_TYPE_UNKNOWN = 0, + QCDM_CMD_PILOT_SETS_TYPE_ACTIVE = 1, + QCDM_CMD_PILOT_SETS_TYPE_CANDIDATE = 2, + QCDM_CMD_PILOT_SETS_TYPE_NEIGHBOR = 3, +}; + +gsize qcdm_cmd_pilot_sets_new (char *buf, + gsize len, + GError **error); + +QCDMResult *qcdm_cmd_pilot_sets_result (const char *buf, + gsize len, + GError **error); + +gboolean qcdm_cmd_pilot_sets_result_get_num (QCDMResult *result, + guint32 set_type, + guint32 *out_num); + +gboolean qcdm_cmd_pilot_sets_result_get_pilot (QCDMResult *result, + guint32 set_type, + guint32 num, + guint32 *out_pn_offset, + guint32 *out_ecio, + float *out_db); + +/**********************************************************************/ + +#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); + +QCDMResult *qcdm_cmd_nv_get_mdn_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +/* Values for QCDM_CMD_NV_GET_ROAM_PREF_ITEM_ROAM_PREF */ +enum { + QCDM_CMD_NV_ROAM_PREF_ITEM_ROAM_PREF_HOME_ONLY = 0x01, + QCDM_CMD_NV_ROAM_PREF_ITEM_ROAM_PREF_ROAM_ONLY = 0x06, + QCDM_CMD_NV_ROAM_PREF_ITEM_ROAM_PREF_AUTO = 0xFF, +}; + +#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); + +QCDMResult *qcdm_cmd_nv_get_roam_pref_result (const char *buf, + gsize len, + GError **error); + +gsize qcdm_cmd_nv_set_roam_pref_new (char *buf, + gsize len, + guint8 profile, + guint8 roam_pref, + GError **error); + +QCDMResult *qcdm_cmd_nv_set_roam_pref_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +/* Values for QCDM_CMD_NV_GET_MODE_PREF_ITEM_MODE_PREF */ +enum { + QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF_AUTO = 0x04, + QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF_1X_ONLY = 0x09, + QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF_HDR_ONLY = 0x0A, +}; + +#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); + +QCDMResult *qcdm_cmd_nv_get_mode_pref_result (const char *buf, + gsize len, + GError **error); + +gsize qcdm_cmd_nv_set_mode_pref_new (char *buf, + gsize len, + guint8 profile, + guint8 mode_pref, + GError **error); + +QCDMResult *qcdm_cmd_nv_set_mode_pref_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE */ +enum { + QCDM_CMD_CM_SUBSYS_STATE_INFO_OPERATING_MODE_ONLINE = 5 +}; + +/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE */ +enum { + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_NO_SERVICE = 0, + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_AMPS = 1, + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_CDMA = 2, + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_GSM = 3, + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_HDR = 4, + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_WCDMA = 5, + QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_GPS = 6 +}; + +/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF */ +enum { + QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_HOME_ONLY = 0x01, + QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_ROAM_ONLY = 0x06, + QCDM_CMD_CM_SUBSYS_STATE_INFO_ROAM_PREF_AUTO = 0xFF, +}; + +/* Values for QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF */ +enum { + /* Note: not the same values as QCDM_CMD_NV_MODE_PREF_ITEM_MODE_PREF has; + * AUTO really is 0x02 here, not 0x04 like the NV item value for AUTO. + */ + QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_DIGITAL_ONLY = 0x01, + QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_AUTO = 0x02, + QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_1X_ONLY = 0x09, + QCDM_CMD_CM_SUBSYS_STATE_INFO_MODE_PREF_HDR_ONLY = 0x0A, +}; + +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_CALL_STATE "call-state" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_OPERATING_MODE "operating-mode" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SYSTEM_MODE "system-mode" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_MODE_PREF "mode-pref" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_BAND_PREF "band-pref" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ROAM_PREF "roam-pref" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_SERVICE_DOMAIN_PREF "service-domain-pref" +#define QCDM_CMD_CM_SUBSYS_STATE_INFO_ITEM_ACQ_ORDER_PREF "acq-order-pref" +#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); + +QCDMResult *qcdm_cmd_cm_subsys_state_info_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_INACTIVE = 0, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_ACQUISITION = 1, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_SYNC = 2, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_IDLE = 3, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_ACCESS = 4, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_AT_STATE_CONNECTED = 5 +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_CLOSED = 0, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_SETUP = 1, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_AT_INIT = 2, /* initiated by Access Terminal */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_AN_INIT = 3, /* initiated by Access Node */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_OPEN = 4, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_CLOSING = 5 +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE (TIA-856-A section 9.2.1) */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_INACTIVE = 0, /* initial state */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_INIT = 1, /* terminal has yet to acquire network */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_IDLE = 2, /* network acquired but no connection */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_CONNECTED = 3, /* open connection to the network */ +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE (TIA-856-A section 9.3.1) */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_INACTIVE = 0, /* protocol waiting for ACTIVATE command */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_NET_DETERMINE = 1, /* choosing a network to operate on */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_ACQUISITION = 2, /* acquiring Forward Pilot Channel */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_INIT_STATE_SYNC = 3, /* synchronizing to Control Channel */ +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE (TIA-856-A section 9.4.1) */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_INACTIVE = 0, /* protocol waiting for ACTIVATE command */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_SLEEP = 1, /* sleeping */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_MONITOR = 2, /* monitoring the Control Channel */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_IDLE_STATE_SETUP = 3, /* setting up a connection */ +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE (TIA-856-A section 9.6.1) */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_INACTIVE = 0, /* protocol waiting for ACTIVATE command */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_OPEN = 1, /* connection is open */ + QCDM_CMD_HDR_SUBSYS_STATE_INFO_CONNECTED_STATE_CLOSING = 2, /* connection is closed */ +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE (TIA-856-A section 9.7.1) */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_INACTIVE = 0, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_IDLE = 1, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_ROUTE_UPDATE_STATE_CONNECTED = 2, +}; + +/* Values for QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_OVERHEAD_MSG (TIA-856-A section 9.9.1) */ +enum { + QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_INIT = 0, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_INACTIVE = 1, + QCDM_CMD_HDR_SUBSYS_STATE_INFO_OVERHEAD_MSG_STATE_ACTIVE = 2, +}; + +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_AT_STATE "at-state" /* State of Access Terminal */ +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_SESSION_STATE "session-state" /* Current session state */ +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ALMP_STATE "almp-state" /* Air Link Management Protocol (ALMP) state */ +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_INIT_STATE "init-state" /* Initialization State Protocol (ISP) state */ +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_IDLE_STATE "idle-state" /* Idle State Protocol (IDP) state */ +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_CONNECTED_STATE "connected-state" /* Connected State Protocol (CSP) state */ +#define QCDM_CMD_HDR_SUBSYS_STATE_INFO_ITEM_ROUTE_UPDATE_STATE "route-update-state" /* Route Update Protocol (RUP) state */ +#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); + +QCDMResult *qcdm_cmd_hdr_subsys_state_info_result (const char *buf, + gsize len, + GError **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); + +QCDMResult *qcdm_cmd_zte_subsys_status_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_RSSI "rssi" + +/* One of QCDM_CDMA_PREV_* */ +#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_PREV "prev" + +/* One of QCDM_CDMA_BAND_CLASS_* */ +#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_BAND_CLASS "band-class" + +#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_ERI "eri" + +/* One of QCDM_HDR_REV_* */ +#define QCDM_CMD_NW_SUBSYS_MODEM_SNAPSHOT_CDMA_ITEM_HDR_REV "hdr-rev" + +enum { + QCDM_NW_CHIPSET_UNKNOWN = 0, + QCDM_NW_CHIPSET_6500 = 1, + QCDM_NW_CHIPSET_6800 = 2, +}; + +gsize qcdm_cmd_nw_subsys_modem_snapshot_cdma_new (char *buf, + gsize len, + guint8 chipset, + GError **error); + +QCDMResult *qcdm_cmd_nw_subsys_modem_snapshot_cdma_result (const char *buf, + gsize len, + GError **error); + +/**********************************************************************/ + +#endif /* LIBQCDM_COMMANDS_H */ diff --git a/libqcdm/src/dm-commands.h b/libqcdm/src/dm-commands.h new file mode 100644 index 0000000..cfc98f7 --- /dev/null +++ b/libqcdm/src/dm-commands.h @@ -0,0 +1,370 @@ +/* -*- 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_DM_COMMANDS_H +#define LIBQCDM_DM_COMMANDS_H + +enum { + DIAG_CMD_VERSION_INFO = 0, /* Version info */ + DIAG_CMD_ESN = 1, /* ESN */ + DIAG_CMD_PEEKB = 2, /* Peek byte */ + DIAG_CMD_PEEKW = 3, /* Peek word */ + DIAG_CMD_PEEKD = 4, /* Peek dword */ + DIAG_CMD_POKEB = 5, /* Poke byte */ + DIAG_CMD_POKEW = 6, /* Poke word */ + DIAG_CMD_POKED = 7, /* Poke dword */ + DIAG_CMD_OUTP = 8, /* Byte output */ + DIAG_CMD_OUTPW = 9, /* Word output */ + DIAG_CMD_INP = 10, /* Byte input */ + DIAG_CMD_INPW = 11, /* Word input */ + DIAG_CMD_STATUS = 12, /* Station status */ + DIAG_CMD_LOGMASK = 15, /* Set logging mask */ + DIAG_CMD_LOG = 16, /* Log packet */ + DIAG_CMD_NV_PEEK = 17, /* Peek NV memory */ + DIAG_CMD_NV_POKE = 18, /* Poke NV memory */ + DIAG_CMD_BAD_CMD = 19, /* Invalid command (response) */ + DIAG_CMD_BAD_PARM = 20, /* Invalid parameter (response) */ + DIAG_CMD_BAD_LEN = 21, /* Invalid packet length (response) */ + DIAG_CMD_BAD_DEV = 22, /* Not accepted by the device (response) */ + DIAG_CMD_BAD_MODE = 24, /* Not allowed in this mode (response) */ + DIAG_CMD_TAGRAPH = 25, /* Info for TA power and voice graphs */ + DIAG_CMD_MARKOV = 26, /* Markov stats */ + DIAG_CMD_MARKOV_RESET = 27, /* Reset Markov stats */ + DIAG_CMD_DIAG_VER = 28, /* Diagnostic Monitor version */ + DIAG_CMD_TIMESTAMP = 29, /* Return a timestamp */ + DIAG_CMD_TA_PARM = 30, /* Set TA parameters */ + DIAG_CMD_MESSAGE = 31, /* Request for msg report */ + DIAG_CMD_HS_KEY = 32, /* Handset emulation -- keypress */ + DIAG_CMD_HS_LOCK = 33, /* Handset emulation -- lock or unlock */ + DIAG_CMD_HS_SCREEN = 34, /* Handset emulation -- display request */ + DIAG_CMD_PARM_SET = 36, /* Parameter download */ + DIAG_CMD_NV_READ = 38, /* Read NV item */ + DIAG_CMD_NV_WRITE = 39, /* Write NV item */ + DIAG_CMD_CONTROL = 41, /* Mode change request */ + DIAG_CMD_ERR_READ = 42, /* Error record retreival */ + DIAG_CMD_ERR_CLEAR = 43, /* Error record clear */ + DIAG_CMD_SER_RESET = 44, /* Symbol error rate counter reset */ + DIAG_CMD_SER_REPORT = 45, /* Symbol error rate counter report */ + DIAG_CMD_TEST = 46, /* Run a specified test */ + DIAG_CMD_GET_DIPSW = 47, /* Retreive the current DIP switch setting */ + DIAG_CMD_SET_DIPSW = 48, /* Write new DIP switch setting */ + DIAG_CMD_VOC_PCM_LB = 49, /* Start/Stop Vocoder PCM loopback */ + DIAG_CMD_VOC_PKT_LB = 50, /* Start/Stop Vocoder PKT loopback */ + DIAG_CMD_ORIG = 53, /* Originate a call */ + DIAG_CMD_END = 54, /* End a call */ + DIAG_CMD_SW_VERSION = 56, /* Get software version */ + DIAG_CMD_DLOAD = 58, /* Switch to downloader */ + DIAG_CMD_TMOB = 59, /* Test Mode Commands and FTM commands*/ + DIAG_CMD_STATE = 63, /* Current state of the phone */ + DIAG_CMD_PILOT_SETS = 64, /* Return all current sets of pilots */ + DIAG_CMD_SPC = 65, /* Send the Service Programming Code to unlock */ + DIAG_CMD_BAD_SPC_MODE = 66, /* Invalid NV read/write because SP is locked */ + DIAG_CMD_PARM_GET2 = 67, /* (obsolete) */ + DIAG_CMD_SERIAL_CHG = 68, /* Serial mode change */ + DIAG_CMD_PASSWORD = 70, /* Send password to unlock secure operations */ + DIAG_CMD_BAD_SEC_MODE = 71, /* Operation not allowed in this security state */ + DIAG_CMD_PRL_WRITE = 72, /* Write PRL */ + DIAG_CMD_PRL_READ = 73, /* Read PRL */ + DIAG_CMD_SUBSYS = 75, /* Subsystem commands */ + DIAG_CMD_FEATURE_QUERY = 81, + DIAG_CMD_SMS_READ = 83, /* Read SMS message out of NV memory */ + DIAG_CMD_SMS_WRITE = 84, /* Write SMS message into NV memory */ + DIAG_CMD_SUP_FER = 85, /* Frame Error Rate info on multiple channels */ + DIAG_CMD_SUP_WALSH_CODES = 86, /* Supplemental channel walsh codes */ + DIAG_CMD_SET_MAX_SUP_CH = 87, /* Sets the maximum # supplemental channels */ + DIAG_CMD_PARM_GET_IS95B = 88, /* Get parameters including SUPP and MUX2 */ + DIAG_CMD_FS_OP = 89, /* Embedded File System (EFS) operations */ + DIAG_CMD_AKEY_VERIFY = 90, /* AKEY Verification */ + DIAG_CMD_HS_BMP_SCREEN = 91, /* Handset Emulation -- Bitmap screen */ + DIAG_CMD_CONFIG_COMM = 92, /* Configure communications */ + DIAG_CMD_EXT_LOGMASK = 93, /* Extended logmask for > 32 bits */ + DIAG_CMD_EVENT_REPORT = 96, /* Static Event reporting */ + DIAG_CMD_STREAMING_CONFIG = 97, /* Load balancing etc */ + DIAG_CMD_PARM_RETRIEVE = 98, /* Parameter retrieval */ + DIAG_CMD_STATUS_SNAPSHOT = 99, /* Status snapshot */ + DIAG_CMD_RPC = 100, /* Used for RPC */ + DIAG_CMD_GET_PROPERTY = 101, + DIAG_CMD_PUT_PROPERTY = 102, + DIAG_CMD_GET_GUID = 103, /* GUID requests */ + DIAG_CMD_USER_CMD = 104, /* User callbacks */ + DIAG_CMD_GET_PERM_PROPERTY = 105, + DIAG_CMD_PUT_PERM_PROPERTY = 106, + DIAG_CMD_PERM_USER_CMD = 107, /* Permanent user callbacks */ + DIAG_CMD_GPS_SESS_CTRL = 108, /* GPS session control */ + DIAG_CMD_GPS_GRID = 109, /* GPS search grid */ + DIAG_CMD_GPS_STATISTICS = 110, + DIAG_CMD_TUNNEL = 111, /* Tunneling command code */ + DIAG_CMD_RAM_RW = 112, /* Calibration RAM control using DM */ + DIAG_CMD_CPU_RW = 113, /* Calibration CPU control using DM */ + DIAG_CMD_SET_FTM_TEST_MODE = 114, /* Field (or Factory?) Test Mode */ +}; + +/* Subsystem IDs used with DIAG_CMD_SUBSYS; these often obsolete many of + * the original DM commands. + */ +enum { + DIAG_SUBSYS_HDR = 5, /* High Data Rate (ie, EVDO) */ + DIAG_SUBSYS_GPS = 13, + DIAG_SUBSYS_SMS = 14, + DIAG_SUBSYS_CM = 15, /* Call manager */ + DIAG_SUBSYS_NW_CONTROL_6500 = 50, /* for Novatel Wireless MSM6500-based devices */ + DIAG_SUBSYS_ZTE = 101, /* for ZTE EVDO devices */ + DIAG_SUBSYS_NW_CONTROL_6800 = 250 /* for Novatel Wireless MSM6800-based devices */ +}; + +/* HDR subsystem command codes */ +enum { + DIAG_SUBSYS_HDR_STATE_INFO = 8, /* Gets EVDO state */ +}; + +enum { + DIAG_SUBSYS_CM_STATE_INFO = 0, /* Gets Call Manager state */ +}; + +/* NW_CONTROL subsystem command codes (only for Novatel Wireless devices) */ +enum { + DIAG_SUBSYS_NW_CONTROL_AT_REQUEST = 3, /* AT commands via diag */ + DIAG_SUBSYS_NW_CONTROL_AT_RESPONSE = 4, + DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT = 7, + DIAG_SUBSYS_NW_CONTROL_ERI = 8, /* Extended Roaming Indicator */ + DIAG_SUBSYS_NW_CONTROL_PRL = 12, +}; + +enum { + DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_CDMA_EVDO = 7, + DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_WCDMA = 20, +}; + +enum { + DIAG_SUBSYS_ZTE_STATUS = 0, +}; + +enum { + CDMA_PREV_UNKNOWN = 0, + CDMA_PREV_IS_95 = 1, /* and J_STD008 */ + CDMA_PREV_IS_95A = 2, + CDMA_PREV_IS_95A_TSB74 = 3, + CDMA_PREV_IS_95B_PHASE1 = 4, + CDMA_PREV_IS_95B_PHASE2 = 5, + CDMA_PREV_IS2000_REL0 = 6, + CDMA_PREV_IS2000_RELA = 7 +}; + +enum { + CDMA_BAND_CLASS_0_CELLULAR_800 = 0, /* US cellular 850MHz */ + CDMA_BAND_CLASS_1_PCS = 1, /* US PCS 1900MHz */ + CDMA_BAND_CLASS_2_TACS = 2, + CDMA_BAND_CLASS_3_JTACS = 3, /* Japanese TACS */ + CDMA_BAND_CLASS_4_KOREAN_PCS = 4, + CDMA_BAND_CLASS_5_NMT450 = 5, + CDMA_BAND_CLASS_6_IMT2000 = 6, /* 2100HMz */ + CDMA_BAND_CLASS_7_CELLULAR_700 = 7, + CDMA_BAND_CLASS_8_1800 = 8, + CDMA_BAND_CLASS_9_900 = 9, + CDMA_BAND_CLASS_10_SECONDARY_800 = 10, + CDMA_BAND_CLASS_11_PAMR_400 = 11, + CDMA_BAND_CLASS_12_PAMR_800 = 12 +}; + +/* Generic DM command header */ +struct DMCmdHeader { + guint8 code; +} __attribute__ ((packed)); +typedef struct DMCmdHeader DMCmdHeader; + +/* DIAG_CMD_SUBSYS */ +struct DMCmdSubsysHeader { + guint8 code; + guint8 subsys_id; + guint16 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; +} __attribute__ ((packed)); +typedef struct DMCmdNVReadWrite DMCmdNVReadWrite; + +/* DIAG_CMD_VERSION_INFO */ +struct DMCmdVersionInfoRsp { + guint8 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; +} __attribute__ ((packed)); +typedef struct DMCmdVersionInfoRsp DMCmdVersionInfoRsp; + +/* DIAG_CMD_ESN */ +struct DMCmdEsnRsp { + guint8 code; + guint8 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; +} __attribute__ ((packed)); +typedef struct DMCmdStatusRsp DMCmdStatusRsp; + +/* DIAG_CMD_SW_VERSION */ +struct DMCmdSwVersionRsp { + guint8 code; + char version[20]; + char comp_date[11]; + char comp_time[8]; +} __attribute__ ((packed)); +typedef struct DMCmdSwVersionRsp DMCmdSwVersionRsp; + +/* 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; +} __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; +} __attribute__ ((packed)); +typedef struct DMCmdSubsysHDRStateInfoRsp DMCmdSubsysHDRStateInfoRsp; + + +/* DIAG_SUBSYS_ZTE_STATUS subsys command */ +struct DMCmdSubsysZteStatusRsp { + DMCmdSubsysHeader header; + guint8 _unknown1[8]; + guint8 signal_ind; + guint8 _unknown2; +} __attribute__ ((packed)); +typedef struct DMCmdSubsysZteStatusRsp DMCmdSubsysZteStatusRsp; + +/* DIAG_CMD_PILOT_SETS command */ +struct DMCmdPilotSetsSet { + guint16 pn_offset; + guint16 ecio; +} __attribute__ ((packed)); +typedef struct DMCmdPilotSetsSet DMCmdPilotSetsSet; + +struct DMCmdPilotSetsRsp { + guint8 code; + guint16 pilot_inc; + guint8 active_count; + guint8 candidate_count; + guint8 neighbor_count; + DMCmdPilotSetsSet sets[52]; +} __attribute__ ((packed)); +typedef struct DMCmdPilotSetsRsp DMCmdPilotSetsRsp; + +/* DIAG_SUBSYS_NW_CONTROL_* subsys command */ +struct DMCmdSubsysNwSnapshotReq { + DMCmdSubsysHeader hdr; + guint8 technology; /* DIAG_SUBSYS_NW_CONTROL_MODEM_SNAPSHOT_TECH_* */ + guint32 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]; +} __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; +} __attribute__ ((packed)); +typedef struct DMCmdSubsysNwSnapshotCdma DMCmdSubsysNwSnapshotCdma; + +#endif /* LIBQCDM_DM_COMMANDS_H */ + diff --git a/libqcdm/src/error.c b/libqcdm/src/error.c new file mode 100644 index 0000000..e3b97a0 --- /dev/null +++ b/libqcdm/src/error.c @@ -0,0 +1,87 @@ +/* -*- 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"), + { 0, 0, 0 } + }; + + etype = g_enum_register_static ("QcdmCommandError", values); + } + + return etype; +} + + diff --git a/libqcdm/src/error.h b/libqcdm/src/error.h new file mode 100644 index 0000000..7a02ae2 --- /dev/null +++ b/libqcdm/src/error.h @@ -0,0 +1,53 @@ +/* -*- 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, +}; + +#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/libqcdm.ver b/libqcdm/src/libqcdm.ver new file mode 100644 index 0000000..b1567e2 --- /dev/null +++ b/libqcdm/src/libqcdm.ver @@ -0,0 +1,6 @@ +{ +global: + nm_vpn_connection_new; +local: + *; +}; diff --git a/libqcdm/src/nv-items.h b/libqcdm/src/nv-items.h new file mode 100644 index 0000000..a0ca10a --- /dev/null +++ b/libqcdm/src/nv-items.h @@ -0,0 +1,64 @@ +/* -*- 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_NV_ITEMS_H +#define LIBQCDM_NV_ITEMS_H + +enum { + DIAG_NV_MODE_PREF = 10, /* Mode preference: 1x, HDR, auto */ + DIAG_NV_DIR_NUMBER = 178, /* Mobile Directory Number (MDN) */ + DIAG_NV_ROAM_PREF = 442, /* Roaming preference */ +}; + + +/* Mode preference values */ +enum { + DIAG_NV_MODE_PREF_AUTO = 0x04, + DIAG_NV_MODE_PREF_1X_ONLY = 0x09, + DIAG_NV_MODE_PREF_HDR_ONLY = 0x0A, +}; + +/* DIAG_NV_MODE_PREF */ +struct DMNVItemModePref { + guint8 profile; + guint8 mode_pref; +} __attribute__ ((packed)); +typedef struct DMNVItemModePref DMNVItemModePref; + +/* DIAG_NV_DIR_NUMBER */ +struct DMNVItemMdn { + guint8 profile; + guint8 mdn[10]; +} __attribute__ ((packed)); +typedef struct DMNVItemMdn DMNVItemMdn; + +/* Roam preference values */ +enum { + DIAG_NV_ROAM_PREF_HOME_ONLY = 0x01, + DIAG_NV_ROAM_PREF_ROAM_ONLY = 0x06, + DIAG_NV_ROAM_PREF_AUTO = 0xFF, +}; + +/* DIAG_NV_ROAM_PREF */ +struct DMNVItemRoamPref { + guint8 profile; + guint8 roam_pref; +} __attribute__ ((packed)); +typedef struct DMNVItemRoamPref DMNVItemRoamPref; + +#endif /* LIBQCDM_NV_ITEMS_H */ + diff --git a/libqcdm/src/result-private.h b/libqcdm/src/result-private.h new file mode 100644 index 0000000..0db63f5 --- /dev/null +++ b/libqcdm/src/result-private.h @@ -0,0 +1,51 @@ +/* -*- 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_RESULT_PRIVATE_H +#define LIBQCDM_RESULT_PRIVATE_H + +#include <glib.h> +#include <glib-object.h> +#include "result.h" + +QCDMResult *qcdm_result_new (void); + +/* For these functions, 'key' *must* be a constant, not allocated and freed */ + +void qcdm_result_add_string (QCDMResult *result, + const char *key, + const char *str); + +void qcdm_result_add_uint8 (QCDMResult *result, + const char *key, + guint8 num); + +void qcdm_result_add_uint32 (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); + +#endif /* LIBQCDM_RESULT_PRIVATE_H */ + diff --git a/libqcdm/src/result.c b/libqcdm/src/result.c new file mode 100644 index 0000000..2440478 --- /dev/null +++ b/libqcdm/src/result.c @@ -0,0 +1,248 @@ +/* -*- 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 <string.h> +#include <glib.h> + +#include "result.h" +#include "result-private.h" +#include "error.h" + +struct QCDMResult { + guint32 refcount; + GHashTable *hash; +}; + + +static void +gvalue_destroy (gpointer data) +{ + GValue *value = (GValue *) data; + + g_value_unset (value); + g_slice_free (GValue, value); +} + +QCDMResult * +qcdm_result_new (void) +{ + QCDMResult *result; + + 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; +} + +QCDMResult * +qcdm_result_ref (QCDMResult *result) +{ + g_return_val_if_fail (result != NULL, NULL); + g_return_val_if_fail (result->refcount > 0, NULL); + + result->refcount++; + return result; +} + +void +qcdm_result_unref (QCDMResult *result) +{ + 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); + } +} + +void +qcdm_result_add_string (QCDMResult *result, + const char *key, + const char *str) +{ + GValue *val; + + 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); +} + +gboolean +qcdm_result_get_string (QCDMResult *result, + const char *key, + const char **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); + 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; +} + +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, + const char *key, + GType btype, + gpointer boxed) +{ + 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, btype); + g_value_set_static_boxed (val, boxed); + + g_hash_table_insert (result->hash, (gpointer) key, val); +} + +gboolean +qcdm_result_get_boxed (QCDMResult *result, + const char *key, + gpointer *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_BOXED (val)); + if (!G_VALUE_HOLDS_BOXED (val)) + return FALSE; + + *out_val = g_value_get_boxed (val); + return TRUE; +} + diff --git a/libqcdm/src/result.h b/libqcdm/src/result.h new file mode 100644 index 0000000..4912b07 --- /dev/null +++ b/libqcdm/src/result.h @@ -0,0 +1,42 @@ +/* -*- 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_RESULT_H +#define LIBQCDM_RESULT_H + +#include <glib.h> + +typedef struct QCDMResult QCDMResult; + +gboolean qcdm_result_get_string (QCDMResult *result, + const char *key, + const char **out_val); + +gboolean qcdm_result_get_uint8 (QCDMResult *result, + const char *key, + guint8 *out_val); + +gboolean qcdm_result_get_uint32 (QCDMResult *result, + const char *key, + guint32 *out_val); + +QCDMResult *qcdm_result_ref (QCDMResult *result); + +void qcdm_result_unref (QCDMResult *result); + +#endif /* LIBQCDM_RESULT_H */ + diff --git a/libqcdm/src/utils.c b/libqcdm/src/utils.c new file mode 100644 index 0000000..b581548 --- /dev/null +++ b/libqcdm/src/utils.c @@ -0,0 +1,311 @@ +/* -*- 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 <stdio.h> +#include <sys/types.h> +#include <unistd.h> +#include <malloc.h> +#include <fcntl.h> +#include <string.h> + +#include "utils.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 + * "async control character" whose value is 0x7E. The frame *and* the CRC are + * escaped before adding the trailing control character so that the control + * character (0x7E) and the escape marker (0x7D) are never seen in the frame. + */ + +/* Table of CRCs for each possible byte, with a generator polynomial of 0x8408 */ +const guint16 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, + 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, + 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, + 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, + 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, + 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, + 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, + 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, + 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, + 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, + 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, + 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, + 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, + 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, + 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, + 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, + 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, + 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, + 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, + 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, + 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, + 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, + 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, + 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, + 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, + 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, + 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, + 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, + 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, + 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 +}; + +/* Calculate the CRC for a buffer using a seed of 0xffff */ +guint16 +crc16 (const char *buffer, gsize len) +{ + guint16 crc = 0xffff; + + while (len--) + crc = crc_table[(crc ^ *buffer++) & 0xff] ^ (crc >> 8); + return ~crc; +} + +#define DIAG_ESC_CHAR 0x7D /* Escape sequence 1st character value */ +#define DIAG_ESC_MASK 0x20 /* Escape sequence complement value */ + +/* Performs DM escaping on inbuf putting the result into outbuf, and returns + * the final length of the buffer. + */ +gsize +dm_escape (const char *inbuf, + gsize inbuf_len, + char *outbuf, + gsize 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); + + /* Since escaping potentially doubles the # of bytes, short-circuit the + * length check if destination buffer is clearly large enough. Note the + * + */ + if (outbuf_len <= inbuf_len << 1) { + size_t outbuf_required = inbuf_len + 1; /* +1 for the trailing control char */ + + /* Each escaped character takes up two bytes in the output buffer */ + while (i--) { + if (*src == DIAG_CONTROL_CHAR || *src == DIAG_ESC_CHAR) + outbuf_required++; + src++; + } + + if (outbuf_len < outbuf_required) + return 0; + } + + /* Do the actual escaping. Replace both the control character and + * the escape character in the source buffer with the following sequence: + * + * <escape_char> <src_byte ^ escape_mask> + */ + src = inbuf; + i = inbuf_len; + while (i--) { + if (*src == DIAG_CONTROL_CHAR || *src == DIAG_ESC_CHAR) { + *dst++ = DIAG_ESC_CHAR; + *dst++ = *src ^ DIAG_ESC_MASK; + } else + *dst++ = *src; + src++; + } + + return (dst - outbuf); +} + +gsize +dm_unescape (const char *inbuf, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len, + gboolean *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); + + for (i = 0, outsize = 0; i < inbuf_len; i++) { + if (*escaping) { + outbuf[outsize++] = inbuf[i] ^ DIAG_ESC_MASK; + *escaping = FALSE; + } else if (inbuf[i] == DIAG_ESC_CHAR) + *escaping = TRUE; + else + outbuf[outsize++] = inbuf[i]; + + /* About to overrun output buffer size */ + if (outsize >= outbuf_len) + return 0; + } + + return outsize; +} + +/** + * dm_encapsulate_buffer: + * @inbuf: buffer in which a valid QCDM packet exists + * @cmd_len: size of the QCDM packet contained in @inbuf + * @inbuf_len: total size of @inbuf itself (not just the packet) + * @outbuf: buffer in which to put the encapsulated QCDM packet + * @outbuf_len: total size of @outbuf + * + * Escapes and CRCs a QCDM packet, and finally adds the trailing control + * character that denotes the end of the QCDM packet. + * + * Returns: size of the encapsulated QCDM command writted to @outbuf. + **/ +gsize +dm_encapsulate_buffer (char *inbuf, + gsize cmd_len, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len) +{ + guint16 crc; + gsize 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); + + /* Add the CRC */ + crc = crc16 (inbuf, cmd_len); + inbuf[cmd_len++] = crc & 0xFF; + 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); + outbuf[escaped_len++] = DIAG_CONTROL_CHAR; + + return escaped_len; +} + +/** + * dm_decapsulate_buffer: + * @inbuf: buffer in which to look for a QCDM packet + * @inbuf_len: length of valid data in @inbuf + * @outbuf: buffer in which to put decapsulated QCDM packet + * @outbuf_len: max size of @outbuf + * @out_decap_len: on success, size of the decapsulated QCDM packet + * @out_used: on either success or failure, amount of data used; caller should + * discard this much data from @inbuf before the next call to this function + * @out_need_more: when TRUE, indicates that more data is required before + * and determination about a valid QCDM packet can be made; caller should add + * more data to @inbuf before calling this function again. + * + * Attempts to retrieve, unescape, and CRC-check a QCDM packet from the given + * buffer. + * + * Returns: FALSE on error (packet was invalid or malformed, or the CRC check + * failed, etc) and places number of bytes to discard from @inbuf in @out_used. + * When TRUE, either more data is required (in which case @out_need_more will + * be TRUE), or a QCDM packet was successfully retrieved from @inbuf and the + * decapsulated packet of length @out_decap_len was placed into @outbuf. In + * all cases the caller should advance the buffer by the number of bytes + * returned in @out_used before calling this function again. + **/ +gboolean +dm_decapsulate_buffer (const char *inbuf, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len, + gsize *out_decap_len, + gsize *out_used, + gboolean *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); + + *out_decap_len = 0; + *out_used = 0; + *out_need_more = FALSE; + + if (inbuf_len < 4) { + *out_need_more = TRUE; + return TRUE; + } + + /* Find the async control character */ + for (i = 0; i < inbuf_len; i++) { + if (inbuf[i] == DIAG_CONTROL_CHAR) { + /* If the control character shows up in a position before a valid + * QCDM packet length (4), the packet is malformed. + */ + if (i < 3) { + /* Tell the caller to advance the buffer past the control char */ + *out_used = i + 1; + return FALSE; + } + + pkt_len = i; + break; + } + } + + /* No control char yet, need more data */ + if (!pkt_len) { + *out_need_more = TRUE; + return TRUE; + } + + /* Unescape first; note that pkt_len */ + unesc_len = dm_unescape (inbuf, pkt_len, outbuf, outbuf_len, &escaping); + if (!unesc_len) { + /* Tell the caller to advance the buffer past the control char */ + *out_used = pkt_len + 1; + return FALSE; + } + + if (escaping) { + *out_need_more = TRUE; + return TRUE; + } + + /* Check the CRC of the packet's data */ + crc = crc16 (outbuf, unesc_len - 2); + pkt_crc = outbuf[unesc_len - 2] & 0xFF; + pkt_crc |= (outbuf[unesc_len - 1] & 0xFF) << 8; + if (crc != pkt_crc) { + *out_used = pkt_len + 1; /* packet + CRC + 0x7E */ + return FALSE; + } + + *out_used = pkt_len + 1; /* packet + CRC + 0x7E */ + *out_decap_len = unesc_len - 2; /* decap_len should not include the CRC */ + return TRUE; +} + diff --git a/libqcdm/src/utils.h b/libqcdm/src/utils.h new file mode 100644 index 0000000..5fccf7f --- /dev/null +++ b/libqcdm/src/utils.h @@ -0,0 +1,54 @@ +/* -*- 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 UTILS_H +#define UTILS_H + +#include <glib.h> + +#define DIAG_CONTROL_CHAR 0x7E +#define DIAG_TRAILER_LEN 3 + +guint16 crc16 (const char *buffer, gsize len); + +gsize dm_escape (const char *inbuf, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len); + +gsize dm_unescape (const char *inbuf, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len, + gboolean *escaping); + +gsize dm_encapsulate_buffer (char *inbuf, + gsize cmd_len, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len); + +gboolean dm_decapsulate_buffer (const char *inbuf, + gsize inbuf_len, + char *outbuf, + gsize outbuf_len, + gsize *out_decap_len, + gsize *out_used, + gboolean *out_need_more); + +#endif /* UTILS_H */ + |