RIL rework: multi-client, more stable, added GPLv3 copyright notice

1 files changed, 124 insertions, 104 deletions

diff --git a/sms.c b/sms.c
index cf8a4d0..9c0cf90 100644
--- a/sms.c
+++ b/sms.c
@@ -1,35 +1,52 @@
+/**
+ * This file is part of samsung-ril.
+ *
+ * Copyright (C) 2010-2011 Joerie de Gram <j.de.gram@gmail.com>
+ * Copyright (C) 2011 Paul Kocialkowski <contact@oaulk.fr>
+ *
+ * samsung-ril is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * samsung-ril 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 samsung-ril.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
 #define LOG_TAG "RIL-SMS"
 #include <utils/Log.h>
 
 #include "samsung-ril.h"
 #include "util.h"
 
-extern const struct RIL_Env *rilenv;
-extern struct radio_state radio;
-extern struct ipc_client *ipc_client;
-
-void respondSmsIncoming(RIL_Token t, void *data, int length)
+void ipc_sms_incoming_msg(struct ipc_message_info *info)
 {
-	struct ipc_sms_incoming_msg *info = (struct ipc_sms_incoming_msg*)data;
-	unsigned char *pdu = ((unsigned char*)data + sizeof(struct ipc_sms_incoming_msg));
+	struct ipc_sms_incoming_msg *msg = (struct ipc_sms_incoming_msg *) info->data;
+	unsigned char *pdu = ((unsigned char *) info->data + sizeof(struct ipc_sms_incoming_msg));
 
-	int resp_length = info->length * 2 + 1;
-	char *resp = (char*)malloc(resp_length);
+	int resp_length = msg->length * 2 + 1;
+	char *resp = (char *) malloc(resp_length);
 
-	bin2hex(pdu, info->length, resp);
+	bin2hex(pdu, msg->length, resp);
 	LOGD("PDU string is '%s'\n", resp);
 
-	if(radio.msg_tpid_lock != 0) {
+	if(ril_state.msg_tpid_lock != 0) {
 		LOGE("Another message is already waiting for ACK, aborting");
 		//FIXME: it would be cleaner to enqueue it
 		goto exit;
 	}
 
-	radio.msg_tpid_lock = info->msg_tpid;
+	ril_state.msg_tpid_lock = msg->msg_tpid;
 
-	if(info->type == IPC_SMS_TYPE_POINT_TO_POINT) {
+	if(msg->type == IPC_SMS_TYPE_POINT_TO_POINT) {
 		RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_NEW_SMS, resp, resp_length);
-	} else if(info->type == IPC_SMS_TYPE_STATUS_REPORT) {
+	} else if(msg->type == IPC_SMS_TYPE_STATUS_REPORT) {
 		RIL_onUnsolicitedResponse(RIL_UNSOL_RESPONSE_NEW_SMS_STATUS_REPORT, resp, resp_length);
 	} else {
 		LOGE("%s: Unknown message type", __FUNCTION__);
@@ -39,31 +56,64 @@ exit:
 	free(resp);
 }
 
-void requestSendSms(RIL_Token t, void *data, size_t datalen)
+unsigned short sms_ack_error_ril2ipc(int success, int failcause)
 {
-	const char **request;
-	request = (char **) data;
-	int pdu_len = strlen(request[1]);
+	if(success) {
+		return IPC_SMS_ACK_NO_ERROR;
+	} else {
+		switch(failcause) {
+			case 0xD3:
+				return IPC_SMS_ACK_PDA_FULL_ERROR;
+			default:
+				return IPC_SMS_ACK_UNSPEC_ERROR;
+		}
+	}
+}
 
-	/* We first need to get SMS SVC before sending the message */
+RIL_Errno sms_ack_error_ipc2ril(unsigned short error)
+{
+	switch(error) {
+		case IPC_SMS_ACK_NO_ERROR:
+			return RIL_E_SUCCESS;
+		default:
+			return RIL_E_GENERIC_FAILURE;
+	}
+}
 
-	if(request[0] == NULL) {
-		LOGD("We have no SMSC, asking one before anything");
+/**
+ * In: RIL_REQUEST_SMS_ACKNOWLEDGE
+ *   Acknowledge successful or failed receipt of SMS previously indicated
+ *   via RIL_UNSOL_RESPONSE_NEW_SMS
+ *
+ * Out: IPC_SMS_DELIVER_REPORT
+ *   Sends a SMS delivery report
+ */
+void ril_request_sms_acknowledge(RIL_Token t, void *data, size_t datalen)
+{
+	struct ipc_sms_deliv_report_msg report_msg;
+	int success = ((int *)data)[0];
+	int failcause = ((int *)data)[1];
 
-		if(radio.tokens.send_sms != 0 && radio.msg_pdu != NULL) {
-			LOGE("Another message is being sent, aborting");
-			//FIXME: it would be cleaner to enqueue it
-		}
+	if(ril_state.msg_tpid_lock == 0) {
+		LOGE("No stored msg_tpid, aborting\n");
+		return;
+	}
 
-		radio.tokens.send_sms = t;
-		radio.msg_pdu = malloc(pdu_len);
-		memcpy(radio.msg_pdu, request[1], pdu_len);
+	report_msg.type = IPC_SMS_TYPE_STATUS_REPORT;
+	report_msg.error = sms_ack_error_ril2ipc(success, failcause);
+	report_msg.msg_tpid = ril_state.msg_tpid_lock;
+	report_msg.unk = 0;
 
-		ipc_client_send_get(IPC_SMS_SVC_CENTER_ADDR, getRequestId(t));
-		
-	} else {
-		sms_send_msg(t, request[1], request[0]);
-	}
+	ril_state.msg_tpid_lock = 0;
+
+	ipc_fmt_send(IPC_SMS_DELIVER_REPORT, IPC_TYPE_EXEC, (void *) &report_msg, sizeof(struct ipc_sms_deliv_report_msg), reqGetId(t));
+}
+
+void ipc_sms_deliver_report(struct ipc_message_info *info)
+{
+	//FIXME: check it's alright from data (or not, no need to check the ACK of our ACK)
+
+	RIL_onRequestComplete(reqGetToken(info->aseq), RIL_E_SUCCESS, NULL, 0);
 }
 
 void sms_send_msg(RIL_Token t, char *pdu, char *smsc_string)
@@ -102,24 +152,41 @@ void sms_send_msg(RIL_Token t, char *pdu, char *smsc_string)
 	p += smsc_len;
 	memcpy(p, decoded_pdu, pdu_len);
 
-	ipc_client_send(ipc_client, IPC_SMS_SEND_MSG, IPC_TYPE_EXEC, data, length, getRequestId(t));
+	ipc_fmt_send(IPC_SMS_SEND_MSG, IPC_TYPE_EXEC, data, length, reqGetId(t));
 
 	/* Wait for ACK to return to RILJ */
-	radio.tokens.send_sms = t;
+	ril_state.tokens.send_sms = t;
 
 	free(decoded_pdu);
 	free(data);
 }
 
-void respondSmsSvcCenterAddr(RIL_Token t, void *data, size_t datalen)
+void ril_request_send_sms(RIL_Token t, void *data, size_t datalen)
 {
-	if(radio.tokens.send_sms == t && radio.msg_pdu != NULL) {
-		sms_send_msg(t, radio.msg_pdu, data);
+	const char **request;
+	request = (char **) data;
+	int pdu_len = strlen(request[1]);
+
+	/* We first need to get SMS SVC before sending the message */
 
-		free(radio.msg_pdu);
+	if(request[0] == NULL) {
+		LOGD("We have no SMSC, asking one before anything");
+
+		if(ril_state.tokens.send_sms != 0 && ril_state.msg_pdu != NULL) {
+			LOGE("Another message is being sent, aborting");
+			//FIXME: it would be cleaner to enqueue it
+		}
+
+		ril_state.tokens.send_sms = t;
+		ril_state.msg_pdu = malloc(pdu_len);
+		memcpy(ril_state.msg_pdu, request[1], pdu_len);
+
+		ipc_fmt_send_get(IPC_SMS_SVC_CENTER_ADDR, reqGetId(t));
+		
+	} else {
+		sms_send_msg(t, request[1], request[0]);
 	}
 }
-
 /**
  * In: RIL_REQUEST_SEND_SMS_EXPECT_MORE
  *   Send an SMS message. Identical to RIL_REQUEST_SEND_SMS,
@@ -128,42 +195,30 @@ void respondSmsSvcCenterAddr(RIL_Token t, void *data, size_t datalen)
  *
  * Out: IPC_SMS_SEND_MSG
  */
-void requestSendSmsExpectMore(RIL_Token t, void *data, size_t datalen)
+void ril_request_send_sms_expect_more(RIL_Token t, void *data, size_t datalen)
 {
 	/* FIXME: We seriously need a decent queue here */
 
 }
 
-unsigned short sms_ack_error_ril2ipc(int success, int failcause)
+void ipc_sms_svc_center_addr(struct ipc_message_info *info)
 {
-	if(success) {
-		return IPC_SMS_ACK_NO_ERROR;
-	} else {
-		switch(failcause) {
-			case 0xD3:
-				return IPC_SMS_ACK_PDA_FULL_ERROR;
-			default:
-				return IPC_SMS_ACK_UNSPEC_ERROR;
-		}
-	}
-}
+	RIL_Token t = reqGetToken(info->aseq);
 
-RIL_Errno sms_ack_error_ipc2ril(unsigned short error)
-{
-	switch(error) {
-		case IPC_SMS_ACK_NO_ERROR:
-			return RIL_E_SUCCESS;
-		default:
-			return RIL_E_GENERIC_FAILURE;
+	if(ril_state.tokens.send_sms == t && ril_state.msg_pdu != NULL) {
+		sms_send_msg(t, ril_state.msg_pdu, info->data);
+
+		free(ril_state.msg_pdu);
 	}
 }
 
-void respondSmsSendMsg(RIL_Token t, void *data, size_t datalen)
+void ipc_sms_send_msg(struct ipc_message_info *info)
 {
-	struct ipc_sms_deliv_report_msg *report_msg = data;
+	struct ipc_sms_deliv_report_msg *report_msg = info->data;
 	RIL_Errno ril_ack_err;
+	RIL_Token t = reqGetToken(info->aseq);
 
-	if(radio.tokens.send_sms != t) {
+	if(ril_state.tokens.send_sms != t) {
 		LOGE("Wrong token to ACK");
 	}
 
@@ -171,53 +226,18 @@ void respondSmsSendMsg(RIL_Token t, void *data, size_t datalen)
 
 	ril_ack_err = sms_ack_error_ipc2ril(report_msg->error);
 
-	radio.tokens.send_sms = 0;
+	ril_state.tokens.send_sms = 0;
 
+	//messageRef = tpid, it's not NULL	↓
 	RIL_onRequestComplete(t, ril_ack_err, NULL, 0);
 
 }
 
-/**
- * In: RIL_REQUEST_SMS_ACKNOWLEDGE
- *   Acknowledge successful or failed receipt of SMS previously indicated
- *   via RIL_UNSOL_RESPONSE_NEW_SMS
- *
- * Out: IPC_SMS_DELIVER_REPORT
- *   Sends a SMS delivery report
- */
-void requestSmsAcknowledge(RIL_Token t, void *data, size_t datalen)
-{
-	struct ipc_sms_deliv_report_msg report_msg;
-	int success = ((int *)data)[0];
-	int failcause = ((int *)data)[1];
-
-	if(radio.msg_tpid_lock == 0) {
-		LOGE("No stored msg_tpid, aborting\n");
-		return;
-	}
-
-	report_msg.type = IPC_SMS_TYPE_STATUS_REPORT;
-	report_msg.error = sms_ack_error_ril2ipc(success, failcause);
-	report_msg.msg_tpid = radio.msg_tpid_lock;
-	report_msg.unk = 0;
-
-	radio.msg_tpid_lock = 0;
-
-	ipc_client_send(ipc_client, IPC_SMS_DELIVER_REPORT, IPC_TYPE_EXEC, (void *) &report_msg, sizeof(struct ipc_sms_deliv_report_msg), getRequestId(t));
-}
-
-void respondSmsDeliverReport(RIL_Token t, void *data, size_t datalen)
-{
-	//FIXME: check it's alright from data (or not, no need to check the ACK of our ACK)
-
-	RIL_onRequestComplete(t, RIL_E_SUCCESS, NULL, 0);
-}
-
-void respondSmsDeviceReady(RIL_Token t, struct ipc_message_info *info)
+void ipc_sms_device_ready(struct ipc_message_info *info)
 {
-	if(radio.radio_state == RADIO_STATE_SIM_READY) {
-		ipc_client_send(ipc_client, IPC_SMS_DEVICE_READY, IPC_TYPE_SET, NULL, 0, getRequestId(t));
+	if(ril_state.radio_state == RADIO_STATE_SIM_READY) {
+		ipc_fmt_send(IPC_SMS_DEVICE_READY, IPC_TYPE_SET, NULL, 0, info->aseq);
 	}
 
-	RadioTokensCheck();
+	ril_tokens_check();
 }