AT: Moved at_send_sync/async to at_response prefix and added new at_send_sync
authorPaul Kocialkowski <contact@paulk.fr>
Tue, 31 Jul 2012 19:07:30 +0000 (21:07 +0200)
committerPaul Kocialkowski <contact@paulk.fr>
Tue, 31 Jul 2012 19:07:30 +0000 (21:07 +0200)
Signed-off-by: Paul Kocialkowski <contact@paulk.fr>
at.c
at.h

diff --git a/at.c b/at.c
index e77d9f9..7763ce8 100644 (file)
--- a/at.c
+++ b/at.c
@@ -1755,62 +1755,7 @@ void at_request_free(struct at_request *request)
        memset(request, 0, sizeof(struct at_request *));
 }
 
-/*
- * Send
- */
-
-int at_send_next_request(void)
-{
-       struct at_sync_request *sync_request = NULL;
-       struct at_async_request *async_request = NULL;
-       struct at_async_request *async_request_sent = NULL;
-       struct at_async_request *async_request_unhandled_status = NULL;
-       struct at_async_request *async_request_unhandled_data = NULL;
-       struct at_request *request = NULL;
-       int rc;
-
-       // Unhandled requests are still going on too
-       sync_request = at_sync_request_find_handled(AT_RESPONSE_SENT);
-       async_request_sent = at_async_request_find_handled(AT_RESPONSE_SENT);
-       async_request_unhandled_status = at_async_request_find_handled(AT_RESPONSE_UNHANDELD_REASON_STATUS);
-       async_request_unhandled_data = at_async_request_find_handled(AT_RESPONSE_UNHANDELD_REASON_DATA);
-
-       if(sync_request != NULL || async_request_sent != NULL || async_request_unhandled_status != NULL || async_request_unhandled_data != NULL) {
-               LOGE("There are still unanswered requests!");
-               return -1;
-       }
-
-       request = at_request_dequeue();
-       if(request == NULL) {
-               LOGD("Nothing left to send!");
-               return -1;
-       }
-
-       rc = at_request_send(request);
-       if(rc < 0) {
-               LOGE("Unable to send request, aborting!");
-               at_request_free(request);
-               return -1;
-       }
-
-       sync_request = at_sync_request_find_request(request);
-       if(sync_request != NULL) {
-               sync_request->handled = AT_RESPONSE_SENT;
-               sync_request->request = NULL;
-       }
-
-       async_request = at_async_request_find_request(request);
-       if(async_request != NULL) {
-               async_request->handled = AT_RESPONSE_SENT;
-               async_request->request = NULL;
-       }
-
-       at_request_free(request);
-
-       return 0;
-}
-
-int at_send_async(struct at_request *request, void *data, RIL_Token token, at_async_request_cb func)
+int at_request_send_async(struct at_request *request, void *data, RIL_Token token, at_async_request_cb func)
 {
        struct at_async_request *async_request = NULL;
        int rc;
@@ -1851,7 +1796,7 @@ int at_send_async(struct at_request *request, void *data, RIL_Token token, at_as
        return 0;
 }
 
-struct at_response *at_send_sync(struct at_request *request)
+struct at_response *at_request_send_sync(struct at_request *request)
 {
        struct at_sync_request *sync_request = NULL;
        struct at_response *response = NULL;
@@ -1913,33 +1858,65 @@ struct at_response *at_send_sync(struct at_request *request)
        return response;
 }
 
-int at_send_expect_to_func(char *command, char *data, void *async_data, RIL_Token token, at_async_request_cb func)
+/*
+ * Send
+ */
+
+int at_send_next_request(void)
 {
+       struct at_sync_request *sync_request = NULL;
+       struct at_async_request *async_request = NULL;
+       struct at_async_request *async_request_sent = NULL;
+       struct at_async_request *async_request_unhandled_status = NULL;
+       struct at_async_request *async_request_unhandled_data = NULL;
        struct at_request *request = NULL;
        int rc;
 
-       request = at_request_create(command, data);
+       // Unhandled requests are still going on too
+       sync_request = at_sync_request_find_handled(AT_RESPONSE_SENT);
+       async_request_sent = at_async_request_find_handled(AT_RESPONSE_SENT);
+       async_request_unhandled_status = at_async_request_find_handled(AT_RESPONSE_UNHANDELD_REASON_STATUS);
+       async_request_unhandled_data = at_async_request_find_handled(AT_RESPONSE_UNHANDELD_REASON_DATA);
+
+       if(sync_request != NULL || async_request_sent != NULL || async_request_unhandled_status != NULL || async_request_unhandled_data != NULL) {
+               LOGE("There are still unanswered requests!");
+               return -1;
+       }
+
+       request = at_request_dequeue();
        if(request == NULL) {
-               LOGE("Unable to create request, aborting");
+               LOGD("Nothing left to send!");
                return -1;
        }
 
-       rc = at_send_async(request, async_data, token, func);
+       rc = at_request_send(request);
        if(rc < 0) {
-               LOGE("Unable to send async request, aborting");
-
+               LOGE("Unable to send request, aborting!");
                at_request_free(request);
                return -1;
        }
 
+       sync_request = at_sync_request_find_request(request);
+       if(sync_request != NULL) {
+               sync_request->handled = AT_RESPONSE_SENT;
+               sync_request->request = NULL;
+       }
+
+       async_request = at_async_request_find_request(request);
+       if(async_request != NULL) {
+               async_request->handled = AT_RESPONSE_SENT;
+               async_request->request = NULL;
+       }
+
+       at_request_free(request);
+
        return 0;
 }
 
-int at_send_expect_status(char *command, char *data)
+struct at_response *at_send_sync(char *command, char *data)
 {
        struct at_request *request = NULL;
        struct at_response *response = NULL;
-       int status;
 
        request = at_request_create(command, data);
        if(request == NULL) {
@@ -1947,17 +1924,48 @@ int at_send_expect_status(char *command, char *data)
                return -1;
        }
 
-       response = at_send_sync(request);
-       if(response == NULL) {
-               LOGE("Unable to get sync response, aborting");
+       response = at_request_send_sync(request);
+
+       at_request_free(request);
+
+       return response;
+}
+
+int at_send_expect_to_func(char *command, char *data, void *async_data, RIL_Token token, at_async_request_cb func)
+{
+       struct at_request *request = NULL;
+       int rc;
+
+       request = at_request_create(command, data);
+       if(request == NULL) {
+               LOGE("Unable to create request, aborting");
+               return -1;
+       }
+
+       rc = at_request_send_async(request, async_data, token, func);
+       if(rc < 0) {
+               LOGE("Unable to send async request, aborting");
 
                at_request_free(request);
                return -1;
        }
 
+       return 0;
+}
+
+int at_send_expect_status(char *command, char *data)
+{
+       struct at_response *response = NULL;
+       int status;
+
+       response = at_send_sync(command, data);
+       if(response == NULL) {
+               LOGE("Unable to get sync response, aborting");
+               return -1;
+       }
+
        status = response->status;
 
-       at_request_free(request);
        at_response_free(response);
 
        return status;
@@ -1993,7 +2001,7 @@ struct at_response *at_send(char *command, char *data)
                return -1;
        }
 
-       response = at_send_sync(request);
+       response = at_request_send_sync(request);
        if(response == NULL) {
                LOGE("Unable to get sync response, aborting");
 
diff --git a/at.h b/at.h
index 4df2dba..d0c9ed6 100644 (file)
--- a/at.h
+++ b/at.h
@@ -257,10 +257,12 @@ int at_sync_response_dequeue(struct at_response *response);
 int at_request_send(struct at_request *request);
 struct at_request *at_request_create(char *command, char *data);
 void at_request_free(struct at_request *request);
+int at_request_send_async(struct at_request *request, void *data, RIL_Token token, at_async_request_cb func);
+struct at_response *at_request_send_sync(struct at_request *request);
 
 // Send
-int at_send_async(struct at_request *request, void *data, RIL_Token token, at_async_request_cb func);
-struct at_response *at_send_sync(struct at_request *request);
+int at_send_next_request(void);
+struct at_response *at_send_sync(char *command, char *data);
 int at_send_expect_to_func(char *command, char *data, void *async_data, RIL_Token token, at_async_request_cb func);
 int at_send_expect_status(char *command, char *data);
 int at_send_noresp(char *command, char *data);