自学教程：C++ CALLBACK_WITH_FAILURE函数代码示例

static void ril_sim_read_record(struct ofono_sim *sim, int fileid,				int record, int length,				const unsigned char *path,				unsigned int path_len,				ofono_sim_read_cb_t cb, void *data){	struct sim_data *sd = ofono_sim_get_data(sim);	struct cb_data *cbd = cb_data_new(cb, data, sd);	char *hex_path;	struct parcel rilp;	DBG("file %04x", fileid);	hex_path = get_path(g_ril_vendor(sd->ril),					sd->app_type, fileid, path, path_len);	if (hex_path == NULL) {		ofono_error("Couldn't build SIM read info request - NULL path");		goto error;	}	parcel_init(&rilp);	parcel_w_int32(&rilp, CMD_READ_RECORD);	parcel_w_int32(&rilp, fileid);	parcel_w_string(&rilp, hex_path);	parcel_w_int32(&rilp, record);      /* P1 */	parcel_w_int32(&rilp, 4);           /* P2 */	parcel_w_int32(&rilp, length);      /* P3 */	parcel_w_string(&rilp, NULL);       /* data; only req'd for writes */	parcel_w_string(&rilp, NULL);       /* pin2; only req'd for writes */	parcel_w_string(&rilp, sd->aid_str); /* AID (Application ID) */	/* sessionId, specific to latest MTK modems (harmless for older ones) */	if (g_ril_vendor(sd->ril) == OFONO_RIL_VENDOR_MTK)		parcel_w_int32(&rilp, 0);	g_ril_append_print_buf(sd->ril, "(cmd=0x%.2X,efid=0x%.4X,path=%s,"					"%d,%d,%d,(null),pin2=(null),aid=%s)",					CMD_READ_RECORD, fileid, hex_path,					record, 4, length, sd->aid_str);	g_free(hex_path);	if (g_ril_send(sd->ril, RIL_REQUEST_SIM_IO, &rilp,				ril_file_io_cb, cbd, g_free) > 0)		return;error:	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, NULL, 0, data);}

static void mtk_pin_retries_cb(struct ril_msg *message, gpointer user_data){	struct cb_data *cbd = user_data;	ofono_sim_pin_retries_cb_t cb = cbd->cb;	struct sim_data *sd = cbd->user;	struct parcel rilp;	char **strv;	char *debug_str;	int pin[MTK_EPINC_NUM_PASSWD];	int num_pin;	if (message->error != RIL_E_SUCCESS) {		ofono_error("Reply failure: %s",				ril_error_to_string(message->error));		goto error;	}	g_ril_init_parcel(message, &rilp);	strv = parcel_r_strv(&rilp);	if (strv == NULL) {		ofono_error("%s: parse error", __func__);		goto error;	}	debug_str = g_strjoinv(",", strv);	g_ril_append_print_buf(sd->ril, "{%d,%s}",					g_strv_length(strv), debug_str);	g_free(debug_str);	g_ril_print_response(sd->ril, message);	num_pin = sscanf(strv[0], "+EPINC:%d,%d,%d,%d",					&pin[0], &pin[1], &pin[2], &pin[3]);	g_strfreev(strv);	if (num_pin != MTK_EPINC_NUM_PASSWD)		goto error;	sd->retries[OFONO_SIM_PASSWORD_SIM_PIN] = pin[0];	sd->retries[OFONO_SIM_PASSWORD_SIM_PIN2] = pin[1];	sd->retries[OFONO_SIM_PASSWORD_SIM_PUK] = pin[2];	sd->retries[OFONO_SIM_PASSWORD_SIM_PUK2] = pin[3];	CALLBACK_WITH_SUCCESS(cb, sd->retries, cbd->data);	return;error:	CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);}

static void ste_cgdcont_cb(gboolean ok, GAtResult *result, gpointer user_data){	struct cb_data *cbd = user_data;	ofono_gprs_context_up_cb_t cb = cbd->cb;	struct ofono_gprs_context *gc = cbd->user;	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);	struct cb_data *ncbd = NULL;	char buf[128];	struct conn_info *conn;	GSList *l;	if (!ok) {		struct ofono_error error;		gcd->active_context = 0;		decode_at_error(&error, g_at_result_final_response(result));		cb(&error, NULL, 0, NULL, NULL, NULL, NULL, cbd->data);		return;	}	ncbd = g_memdup(cbd, sizeof(struct cb_data));	l = g_slist_find_custom(g_caif_devices, GUINT_TO_POINTER(0),				conn_compare_by_cid);	if (!l) {		DBG("at_cgdcont_cb, no more available devices");		goto error;	}	conn = l->data;	conn->cid = gcd->active_context;	snprintf(buf, sizeof(buf), "AT*EPPSD=1,%u,%u",			conn->channel_id, conn->cid);	if (g_at_chat_send(gcd->chat, buf, NULL,				ste_eppsd_up_cb, ncbd, g_free) > 0)		return;error:	if (ncbd)		g_free(ncbd);	gcd->active_context = 0;	CALLBACK_WITH_FAILURE(cb, NULL, 0, NULL, NULL,				NULL, NULL, cbd->data);}

static void ril_rat_mode_cb(struct ril_msg *message, gpointer user_data){	DBG("");	struct cb_data *cbd = user_data;	ofono_radio_settings_rat_mode_query_cb_t cb = cbd->cb;	struct parcel rilp;	int mode = OFONO_RADIO_ACCESS_MODE_ANY;	int pref;	if (message->error == RIL_E_SUCCESS) {		ril_util_init_parcel(message, &rilp);		/*first item in int[] is len so let's skip that*/		parcel_r_int32(&rilp);		pref = parcel_r_int32(&rilp);		switch (pref) {		case PREF_NET_TYPE_LTE_ONLY:			mode = OFONO_RADIO_ACCESS_MODE_LTE;		case PREF_NET_TYPE_GSM_ONLY:			mode = OFONO_RADIO_ACCESS_MODE_GSM;			break;		case PREF_NET_TYPE_GSM_WCDMA_AUTO:/* according to UI design */			if (!cb)				ril_force_rat_mode(cbd->user, pref);		case PREF_NET_TYPE_WCDMA:		case PREF_NET_TYPE_GSM_WCDMA: /* according to UI design */			mode = OFONO_RADIO_ACCESS_MODE_UMTS;			break;		case PREF_NET_TYPE_LTE_CDMA_EVDO:		case PREF_NET_TYPE_LTE_GSM_WCDMA:		case PREF_NET_TYPE_LTE_CMDA_EVDO_GSM_WCDMA:			if (!cb)				ril_force_rat_mode(cbd->user, pref);			break;		case PREF_NET_TYPE_CDMA_EVDO_AUTO:		case PREF_NET_TYPE_CDMA_ONLY:		case PREF_NET_TYPE_EVDO_ONLY:		case PREF_NET_TYPE_GSM_WCDMA_CDMA_EVDO_AUTO:		default:			break;		}		if (cb)			CALLBACK_WITH_SUCCESS(cb, mode, cbd->data);	} else {		if (cb)			CALLBACK_WITH_FAILURE(cb, -1, cbd->data);		ofono_error("rat mode query failed");	}}

static void ste_set_rat_mode(struct ofono_radio_settings *rs,				enum ofono_radio_access_mode mode,				ofono_radio_settings_rat_mode_set_cb_t cb,				void *data){	struct radio_settings_data *rsd = ofono_radio_settings_get_data(rs);	struct cb_data *cbd = cb_data_new(cb, data);	char buf[20];	enum ste_radio_mode value;	if (!ofono_mode_to_ste_mode(mode, &value)) {		CALLBACK_WITH_FAILURE(cb, data);		g_free(cbd);		return;	}	snprintf(buf, sizeof(buf), "AT+CFUN=%u", value);	if (g_at_chat_send(rsd->chat, buf, none_prefix,					rat_modify_cb, cbd, g_free) == 0) {		CALLBACK_WITH_FAILURE(cb, data);		g_free(cbd);	}}

static void at_discover_apps(struct ofono_sim_auth *sa,				ofono_sim_list_apps_cb_t cb,				void *data){	struct sim_auth_data *sad = ofono_sim_auth_get_data(sa);	struct cb_data *cbd = cb_data_new(cb, data);	if (g_at_chat_send(sad->chat, "AT+CUAD", cuad_prefix,					at_discover_apps_cb, cbd, g_free) > 0)		return;	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, NULL, 0, data);}

static void ril_clir_query(struct ofono_call_settings *cs,			ofono_call_settings_clir_cb_t cb, void *data){	struct settings_data *sd = ofono_call_settings_get_data(cs);	struct cb_data *cbd = cb_data_new(cb, data, cs);	int ret;	ret = g_ril_send(sd->ril, RIL_REQUEST_GET_CLIR, NULL,				ril_clir_query_cb, cbd, g_free);	if (ret <= 0) {		g_free(cbd);		CALLBACK_WITH_FAILURE(cb, -1, -1, data);	}}

static void at_query_revision(struct ofono_devinfo *info,				ofono_devinfo_query_cb_t cb, void *data){	struct cb_data *cbd = cb_data_new(cb, data);	GAtChat *chat = ofono_devinfo_get_data(info);	cbd->user = "+CGMR:";	if (g_at_chat_send(chat, "AT+CGMR", NULL, attr_cb, cbd, g_free) > 0)		return;	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, NULL, data);}

static void ril_set_rat_cb(struct ril_msg *message, gpointer user_data){	struct cb_data *cbd = user_data;	struct ofono_radio_settings *rs = cbd->user;	struct radio_data *rd = ofono_radio_settings_get_data(rs);	ofono_radio_settings_rat_mode_set_cb_t cb = cbd->cb;	if (message->error == RIL_E_SUCCESS) {		g_ril_print_response_no_args(rd->ril, message);		CALLBACK_WITH_SUCCESS(cb, cbd->data);	} else {		ofono_error("%s: rat mode setting failed", __func__);		CALLBACK_WITH_FAILURE(cb, cbd->data);	}}

static void ril_read_imsi(struct ofono_sim *sim, ofono_sim_imsi_cb_t cb,				void *data){	struct sim_data *sd = ofono_sim_get_data(sim);	struct cb_data *cbd = cb_data_new(cb, data, sd);	struct parcel rilp;	g_ril_request_read_imsi(sd->ril, sd->aid_str, &rilp);	if (g_ril_send(sd->ril, RIL_REQUEST_GET_IMSI, &rilp,			ril_imsi_cb, cbd, g_free) == 0) {		g_free(cbd);		CALLBACK_WITH_FAILURE(cb, NULL, data);	}}

static void ril_ussd_cancel(struct ofono_ussd *ussd,				ofono_ussd_cb_t cb, void *user_data){	struct ussd_data *ud = ofono_ussd_get_data(ussd);	struct cb_data *cbd = cb_data_new(cb, user_data, ussd);	int ret;	ret = g_ril_send(ud->ril, RIL_REQUEST_CANCEL_USSD, NULL,				ril_ussd_cancel_cb, cbd, g_free);	if (ret <= 0) {		g_free(cbd);		CALLBACK_WITH_FAILURE(cb, user_data);	}}

static void at_discover_apps_cb(gboolean ok, GAtResult *result,				gpointer user_data){	struct cb_data *cbd = user_data;	GAtResultIter iter;	ofono_sim_list_apps_cb_t cb = cbd->cb;	struct ofono_error error;	const unsigned char *dataobj;	gint linelen;	unsigned char *buffer;	int len;	decode_at_error(&error, g_at_result_final_response(result));	if (!ok) {		cb(&error, NULL, 0, cbd->data);		return;	}	g_at_result_iter_init(&iter, result);	len = 0;	while (g_at_result_iter_next(&iter, "+CUAD:")) {		if (!g_at_result_iter_next_hexstring(&iter, NULL, &linelen))			goto error;		len += linelen;	}	g_at_result_iter_init(&iter, result);	buffer = g_malloc(len);	len = 0;	while (g_at_result_iter_next(&iter, "+CUAD:")) {		g_at_result_iter_next_hexstring(&iter, &dataobj, &linelen);		memcpy(buffer + len, dataobj, linelen);		len += linelen;	}	cb(&error, buffer, len, cbd->data);	g_free(buffer);	return;error:	CALLBACK_WITH_FAILURE(cb, NULL, 0, cbd->data);}

static void ril_registration(struct ofono_call_forwarding *cf, int type,                             int cls,                             const struct ofono_phone_number *number,                             int time, ofono_call_forwarding_set_cb_t cb,                             void *data){    struct forw_data *fd = ofono_call_forwarding_get_data(cf);    struct cb_data *cbd = cb_data_new(cb, data);    struct parcel rilp;    int ret = 0;    ofono_info("cf registration");    parcel_init(&rilp);    parcel_w_int32(&rilp, CF_ACTION_REGISTRATION);    parcel_w_int32(&rilp, type);    /*     * Modem seems to respond with error to all queries     * or settings made with bearer class     * BEARER_CLASS_DEFAULT. Design decision: If given     * class is BEARER_CLASS_DEFAULT let's map it to     * SERVICE_CLASS_NONE as with it e.g. ./send-ussd '*21*<phone_number>#'     * returns cls:53 i.e. 1+4+16+32 as service class.    */    if (cls == BEARER_CLASS_DEFAULT)        cls = SERVICE_CLASS_NONE;    parcel_w_int32(&rilp, cls);    parcel_w_int32(&rilp, number->type);    parcel_w_string(&rilp, (char *) number->number);    parcel_w_int32(&rilp, time);    ret = g_ril_send(fd->ril, RIL_REQUEST_SET_CALL_FORWARD,                     rilp.data, rilp.size, ril_set_forward_cb, cbd, g_free);    /* In case of error free cbd and return the cb with failure */    if (ret <= 0) {        ofono_error("CF registration failed");        g_free(cbd);        CALLBACK_WITH_FAILURE(cb, data);    }}

static void cgact_disable_cb(gboolean ok, GAtResult *result, gpointer user_data){	struct ofono_gprs_context *gc = user_data;	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);	DBG("ok %d", ok);	if (!ok) {		CALLBACK_WITH_FAILURE(gcd->cb, gcd->cb_data);		return;	}	gcd->active_context = 0;	CALLBACK_WITH_SUCCESS(gcd->cb, gcd->cb_data);}

static void hfp_signal_strength(struct ofono_netreg *netreg,				ofono_netreg_strength_cb_t cb, void *data){	struct netreg_data *nd = ofono_netreg_get_data(netreg);	struct cb_data *cbd = cb_data_new(cb, data);	cbd->user = netreg;	if (g_at_chat_send(nd->chat, "AT+CIND?", cind_prefix,				signal_strength_cb, cbd, g_free) > 0)		return;	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, -1, data);}

static void qmi_signal_strength(struct ofono_netreg *netreg,				ofono_netreg_strength_cb_t cb, void *user_data){	struct netreg_data *data = ofono_netreg_get_data(netreg);	struct cb_data *cbd = cb_data_new(cb, user_data);	DBG("");	if (qmi_service_send(data->nas, QMI_NAS_GET_RSSI, NULL,					get_rssi_cb, cbd, g_free) > 0)		return;	CALLBACK_WITH_FAILURE(cb, -1, cbd->data);	g_free(cbd);}

static void qmi_list_operators(struct ofono_netreg *netreg,			ofono_netreg_operator_list_cb_t cb, void *user_data){	struct netreg_data *data = ofono_netreg_get_data(netreg);	struct cb_data *cbd = cb_data_new(cb, user_data);	DBG("");	if (qmi_service_send(data->nas, QMI_NAS_SCAN_NETS, NULL,					scan_nets_cb, cbd, g_free) > 0)		return;	CALLBACK_WITH_FAILURE(cb, 0, NULL, cbd->data);	g_free(cbd);}

static void enter_pin_done(const struct ofono_error *error, void *data){	struct change_state_cbd *csd = data;	struct sim_data *sd = ofono_sim_get_data(csd->sim);	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {		ofono_error("%s: wrong password", __func__);		sd->unlock_pending = FALSE;		CALLBACK_WITH_FAILURE(csd->cb, csd->data);	} else {		ril_pin_change_state(csd->sim, csd->passwd_type, csd->enable,					csd->passwd, csd->cb, csd->data);	}	g_free(csd);}

static void isi_sca_query(struct ofono_sms *sms,				ofono_sms_sca_query_cb_t cb, void *data){	struct sms_data *sd = ofono_sms_get_data(sms);	struct isi_cb_data *cbd = isi_cb_data_new(sms, cb, data);	if (cbd == NULL || sd->sim == NULL)		goto error;	if (sca_sim_query(sd->sim, cbd, g_free))		return;error:	CALLBACK_WITH_FAILURE(cb, NULL, data);	g_free(cbd);}

static void ril_set_online_cb(struct ril_msg *message, gpointer user_data){	struct cb_data *cbd = user_data;	struct ril_data *rd = cbd->user;	ofono_modem_online_cb_t cb = cbd->cb;	if (message->error == RIL_E_SUCCESS) {		DBG("%s: set_online OK: rd->ofono_online: %d", __func__,			rd->ofono_online);		CALLBACK_WITH_SUCCESS(cb, cbd->data);	} else {		ofono_error("%s: set_online: %d failed", __func__,				rd->ofono_online);		CALLBACK_WITH_FAILURE(cb, cbd->data);	}}

static void tc65_set_online(struct ofono_modem *modem, ofono_bool_t online,			ofono_modem_online_cb_t cb, void *user_data){	GAtChat *chat = ofono_modem_get_data(modem);	struct cb_data *cbd = cb_data_new(cb, user_data);	char const *command = online ? "AT+CFUN=1" : "AT+CFUN=7";	DBG("modem %p %s", modem, online ? "online" : "offline");	if (g_at_chat_send(chat, command, NULL, set_online_cb, cbd, g_free))		return;	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, cbd->data);}

static void qmi_read_imsi(struct ofono_sim *sim,				ofono_sim_imsi_cb_t cb, void *user_data){	struct sim_data *data = ofono_sim_get_data(sim);	struct cb_data *cbd = cb_data_new(cb, user_data);	DBG("");	if (qmi_service_send(data->dms, QMI_DMS_GET_IMSI, NULL,					get_imsi_cb, cbd, g_free) > 0)		return;	CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);	g_free(cbd);}

static void phonesim_ctm_query(struct ofono_ctm *ctm,				ofono_ctm_query_cb_t cb, void *data){	GAtChat *chat = ofono_ctm_get_data(ctm);	struct cb_data *cbd = cb_data_new(cb, data);	DBG("");	if (g_at_chat_send(chat, "AT+PTTY?", ptty_prefix,				ctm_query_cb, cbd, g_free) > 0)		return;	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, 0, data);}

static void qmi_read_file_info(struct ofono_sim *sim, int fileid,				ofono_sim_file_info_cb_t cb, void *user_data){	unsigned char access[3] = { 0x0f, 0xff, 0xff };	DBG("file id 0x%04x", fileid);	switch (fileid) {	case SIM_EF_ICCID_FILEID:		CALLBACK_WITH_SUCCESS(cb, 10, 0, 0, access, 1, user_data);		break;	default:		CALLBACK_WITH_FAILURE(cb, -1, -1, -1, NULL, 0, user_data);		break;	}}

static void ril_clip_query(struct ofono_call_settings *cs,			ofono_call_settings_status_cb_t cb, void *data){	struct settings_data *sd = ofono_call_settings_get_data(cs);	struct cb_data *cbd = cb_data_new(cb, data, cs);	int ret;	ret = g_ril_send(sd->ril, RIL_REQUEST_QUERY_CLIP, NULL,				ril_clip_query_cb, cbd, g_free);	/* In case of error free cbd and return the cb with failure */	if (ret <= 0) {		g_free(cbd);		CALLBACK_WITH_FAILURE(cb, -1, data);	}}

static void ril_call_barring_query(struct ofono_call_barring *cb,					const char *lock, int cls,					ofono_call_barring_query_cb_t callback,					void *data){	struct barring_data *bd = ofono_call_barring_get_data(cb);	struct cb_data *cbd = cb_data_new(callback, data);	struct parcel rilp;	int ret = 0;	char cls_textual[RIL_MAX_SERVICE_LENGTH];	DBG("lock: %s, services to query: %i", lock, cls);	/*	 * RIL modems do not support 7 as default bearer class. According to	 * the 22.030 Annex C: When service code is not given it corresponds to	 * "All tele and bearer services"	 */	if (cls == BEARER_CLASS_DEFAULT)		cls = SERVICE_CLASS_NONE;	sprintf(cls_textual, "%d", cls);	/*	 * See 3GPP 27.007 7.4 for parameter descriptions.	 * According to ril.h password should be empty string "" when not	 * needed, but in reality we only need to give string length as 0	 */	parcel_init(&rilp);	parcel_w_int32(&rilp, RIL_QUERY_STRING_COUNT);	/* Nbr of strings */	parcel_w_string(&rilp, (char *) lock);		/* Facility code */	parcel_w_int32(&rilp, RIL_LENGTH_ZERO);		/* Password length */	parcel_w_string(&rilp, (char *) cls_textual);	parcel_w_string(&rilp, NULL); /* AID (for FDN, not yet supported) */	ret = g_ril_send(bd->ril, RIL_REQUEST_QUERY_FACILITY_LOCK,			rilp.data, rilp.size, ril_call_barring_query_cb,			cbd, g_free);	parcel_free(&rilp);	if (ret <= 0) {		ofono_error("Sending Call Barring query failed, err: %i", ret);		g_free(cbd);		CALLBACK_WITH_FAILURE(callback, -1, data);	}}

static void ril_registration(struct ofono_call_forwarding *cf, int type,				int cls,				const struct ofono_phone_number *number,				int time, ofono_call_forwarding_set_cb_t cb,				void *data){	struct forw_data *fd = ofono_call_forwarding_get_data(cf);	struct cb_data *cbd = cb_data_new(cb, data);	struct parcel rilp;	int ret = 0;	parcel_init(&rilp);	parcel_w_int32(&rilp, CF_ACTION_REGISTRATION);	parcel_w_int32(&rilp, type);	/* Modem seems to respond with error to all queries	 * or settings made with bearer class	 * BEARER_CLASS_DEFAULT. Design decision: If given	 * class is BEARER_CLASS_DEFAULT let's map it to	 * SERVICE_CLASS_VOICE effectively making it the	 * default bearer. This in line with API which is	 * contains only voice anyways. TODO: Checkout	 * the behaviour with final modem	*/	if (cls == BEARER_CLASS_DEFAULT)		cls = BEARER_CLASS_VOICE;	parcel_w_int32(&rilp, cls);	parcel_w_int32(&rilp, number->type);	parcel_w_string(&rilp, (char *) number->number);	parcel_w_int32(&rilp, time);	ret = g_ril_send(fd->ril, RIL_REQUEST_SET_CALL_FORWARD,		rilp.data, rilp.size, ril_set_forward_cb, cbd, g_free);	/* In case of error free cbd and return the cb with failure */	if (ret <= 0) {		g_free(cbd);		CALLBACK_WITH_FAILURE(cb, data);	}}

static void phonesim_activate_primary(struct ofono_gprs_context *gc,				const struct ofono_gprs_primary_context *ctx,				ofono_gprs_context_cb_t cb, void *data){	struct gprs_context_data *gcd = ofono_gprs_context_get_data(gc);	struct cb_data *cbd = cb_data_new(cb, data);	char buf[OFONO_GPRS_MAX_APN_LENGTH + 128];	int len = 0;	cbd->user = gc;	gcd->proto = ctx->proto;	switch (ctx->proto) {	case OFONO_GPRS_PROTO_IP:		len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,/"IP/"",				ctx->cid);		break;	case OFONO_GPRS_PROTO_IPV6:		len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,/"IPV6/"",				ctx->cid);		break;	case OFONO_GPRS_PROTO_IPV4V6:		len = snprintf(buf, sizeof(buf), "AT+CGDCONT=%u,/"IPV4V6/"",				ctx->cid);		break;	}	if (ctx->apn)		snprintf(buf + len, sizeof(buf) - len - 3, ",/"%s/"",				ctx->apn);	/* Assume always succeeds */	if (g_at_chat_send(gcd->chat, buf, none_prefix, NULL, NULL, NULL) == 0)		goto error;	sprintf(buf, "AT+CGACT=1,%u", ctx->cid);	if (g_at_chat_send(gcd->chat, buf, none_prefix,				at_cgact_up_cb, cbd, g_free) > 0)		return;error:	g_free(cbd);	CALLBACK_WITH_FAILURE(cb, data);}

static void cops_cb(gboolean ok, GAtResult *result, gpointer user_data){	struct cb_data *cbd = user_data;	ofono_netreg_operator_cb_t cb = cbd->cb;	struct ofono_network_operator op;	GAtResultIter iter;	int format;	const char *name;	struct ofono_error error;	decode_at_error(&error, g_at_result_final_response(result));	if (!ok) {		cb(&error, NULL, cbd->data);		return;	}	g_at_result_iter_init(&iter, result);	if (!g_at_result_iter_next(&iter, "+COPS:"))		goto error;	g_at_result_iter_skip_next(&iter);	ok = g_at_result_iter_next_number(&iter, &format);	if (ok == FALSE || format != 0)		goto error;	if (g_at_result_iter_next_string(&iter, &name) == FALSE)		goto error;	strncpy(op.name, name, HFP_MAX_OPERATOR_NAME_LENGTH);	op.name[HFP_MAX_OPERATOR_NAME_LENGTH] = '/0';	op.mcc[0] = '/0';	op.mnc[0] = '/0';	op.status = 2;	op.tech = -1;	cb(&error, &op, cbd->data);	return;error:	CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);}

static void telit_portcfg_check_cb(gboolean ok, GAtResult *result,					gpointer user_data){	struct cb_data *cbd = user_data;	ofono_location_reporting_enable_cb_t cb = cbd->cb;	struct ofono_location_reporting *lr = cbd->user;	struct gps_data *gd = ofono_location_reporting_get_data(lr);	struct ofono_error error;	int requested_portcfg, current_portcfg;	GAtResultIter iter;	DBG("lr=%p ok=%d", lr, ok);	decode_at_error(&error, g_at_result_final_response(result));	if (!ok) {		cb(&error, -1, cbd->data);		g_free(cbd);		return;	}	g_at_result_iter_init(&iter, result);	if (!g_at_result_iter_next(&iter, "#PORTCFG:"))		goto fail;	if (!g_at_result_iter_next_number(&iter, &requested_portcfg))		goto fail;	if (!g_at_result_iter_next_number(&iter, &current_portcfg))		goto fail;	if (current_portcfg != 8) {		ofono_warn("Unable to start GPS, modem configuration invalid");		ofono_warn("Refer to doc/telit-modem.txt section HE910/GPS");		goto fail;	}	if (g_at_chat_send(gd->chat, "AT$GPSP=1", none_prefix,				telit_gps_enable_cb, cbd, NULL) > 0)		return;fail:	CALLBACK_WITH_FAILURE(cb, -1, cbd->data);	g_free(cbd);}