Changes in uspace/lib/c/generic/net/modules.c [64d2b10:c7a8442] in mainline

File:

• uspace/lib/c/generic/net/modules.c (modified) (13 diffs)

uspace/lib/c/generic/net/modules.c

@@ -32 +32 @@
 
 /** @file
- * Generic module functions implementation.
+ * Generic module functions implementation. 
  *
  * @todo MAKE IT POSSIBLE TO REMOVE THIS FILE VIA EITHER REPLACING PART OF ITS
@@ -41 +41 @@
 #include <async.h>
 #include <malloc.h>
-#include <errno.h>
+#include <err.h>
 #include <sys/time.h>
+
+#include <ipc/ipc.h>
 #include <ipc/services.h>
+
 #include <net/modules.h>
 
@@ -49 +52 @@
 #define MODULE_WAIT_TIME        (10 * 1000)
 
-/** Answer a call.
- *
- * @param[in] callid Call identifier.
- * @param[in] result Message processing result.
- * @param[in] answer Message processing answer.
- * @param[in] count  Number of answer parameters.
- *
- */
-void answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
-    size_t count)
-{
-        /* Choose the most efficient function */
-        if ((answer != NULL) || (count == 0)) {
-                switch (count) {
+/** Answers the call.
+ *
+ * @param[in] callid    The call identifier.
+ * @param[in] result    The message processing result.
+ * @param[in] answer    The message processing answer.
+ * @param[in] answer_count The number of answer parameters.
+ */
+void
+answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
+    int answer_count)
+{
+        // choose the most efficient answer function
+        if (answer || (!answer_count)) {
+                switch (answer_count) {
                 case 0:
-                        async_answer_0(callid, (sysarg_t) result);
+                        ipc_answer_0(callid, (ipcarg_t) result);
                         break;
                 case 1:
-                        async_answer_1(callid, (sysarg_t) result,
+                        ipc_answer_1(callid, (ipcarg_t) result,
                             IPC_GET_ARG1(*answer));
                         break;
                 case 2:
-                        async_answer_2(callid, (sysarg_t) result,
+                        ipc_answer_2(callid, (ipcarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer));
                         break;
                 case 3:
-                        async_answer_3(callid, (sysarg_t) result,
+                        ipc_answer_3(callid, (ipcarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
                             IPC_GET_ARG3(*answer));
                         break;
                 case 4:
-                        async_answer_4(callid, (sysarg_t) result,
+                        ipc_answer_4(callid, (ipcarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
                             IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer));
@@ -86 +89 @@
                 case 5:
                 default:
-                        async_answer_5(callid, (sysarg_t) result,
+                        ipc_answer_5(callid, (ipcarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
                             IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer),
@@ -108 +111 @@
  *                      function.
  */
-int bind_service(services_t need, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+int bind_service(services_t need, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3,
     async_client_conn_t client_receiver)
 {
@@ -131 +134 @@
  *
  */
-int bind_service_timeout(services_t need, sysarg_t arg1, sysarg_t arg2,
-    sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
-{
+int bind_service_timeout(services_t need, ipcarg_t arg1, ipcarg_t arg2,
+    ipcarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
+{
+        ERROR_DECLARE;
+        
         /* Connect to the needed service */
         int phone = connect_to_service_timeout(need, timeout);
         if (phone >= 0) {
                 /* Request the bidirectional connection */
-                int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver);
-                if (rc != EOK) {
-                        async_hangup(phone);
-                        return rc;
+                ipcarg_t phonehash;
+                if (ERROR_OCCURRED(ipc_connect_to_me(phone, arg1, arg2, arg3,
+                    &phonehash))) {
+                        ipc_hangup(phone);
+                        return ERROR_CODE;
                 }
+                async_new_connection(phonehash, 0, NULL, client_receiver);
         }
         
@@ -151 +158 @@
  *
  * @param[in] need      The needed module service.
- * @return              The phone of the needed service.
+ * @returns             The phone of the needed service.
  */
 int connect_to_service(services_t need)
@@ -163 +170 @@
  *  @param[in] timeout  The connection timeout in microseconds. No timeout if
  *                      set to zero (0).
- *  @return             The phone of the needed service.
- *  @return             ETIMEOUT if the connection timeouted.
+ *  @returns            The phone of the needed service.
+ *  @returns            ETIMEOUT if the connection timeouted.
  */
 int connect_to_service_timeout(services_t need, suseconds_t timeout)
@@ -170 +177 @@
         int phone;
 
-        /* If no timeout is set */
+        // if no timeout is set
         if (timeout <= 0)
                 return async_connect_me_to_blocking(PHONE_NS, need, 0, 0);
@@ -179 +186 @@
                         return phone;
 
-                /* Abort if no time is left */
+                // end if no time is left
                 if (timeout <= 0)
                         return ETIMEOUT;
 
-                /* Wait the minimum of the module wait time and the timeout */
+                // wait the minimum of the module wait time and the timeout
                 usleep((timeout <= MODULE_WAIT_TIME) ?
                     timeout : MODULE_WAIT_TIME);
@@ -190 +197 @@
 }
 
+/** Receives data from the other party.
+ *
+ * The received data buffer is allocated and returned.
+ *
+ * @param[out] data     The data buffer to be filled.
+ * @param[out] length   The buffer length.
+ * @returns             EOK on success.
+ * @returns             EBADMEM if the data or the length parameter is NULL.
+ * @returns             EINVAL if the client does not send data.
+ * @returns             ENOMEM if there is not enough memory left.
+ * @returns             Other error codes as defined for the
+ *                      async_data_write_finalize() function.
+ */
+int data_receive(void **data, size_t *length)
+{
+        ERROR_DECLARE;
+
+        ipc_callid_t callid;
+
+        if (!data || !length)
+                return EBADMEM;
+
+        // fetch the request
+        if (!async_data_write_receive(&callid, length))
+                return EINVAL;
+
+        // allocate the buffer
+        *data = malloc(*length);
+        if (!*data)
+                return ENOMEM;
+
+        // fetch the data
+        if (ERROR_OCCURRED(async_data_write_finalize(callid, *data, *length))) {
+                free(data);
+                return ERROR_CODE;
+        }
+
+        return EOK;
+}
+
 /** Replies the data to the other party.
  *
  * @param[in] data      The data buffer to be sent.
  * @param[in] data_length The buffer length.
- * @return              EOK on success.
- * @return              EINVAL if the client does not expect the data.
- * @return              EOVERFLOW if the client does not expect all the data.
+ * @returns             EOK on success.
+ * @returns             EINVAL if the client does not expect the data.
+ * @returns             EOVERFLOW if the client does not expect all the data.
  *                      Only partial data are transfered.
- * @return              Other error codes as defined for the
+ * @returns             Other error codes as defined for the
  *                      async_data_read_finalize() function.
  */
@@ -206 +253 @@
         ipc_callid_t callid;
 
-        /* Fetch the request */
+        // fetch the request
         if (!async_data_read_receive(&callid, &length))
                 return EINVAL;
 
-        /* Check the requested data size */
+        // check the requested data size
         if (length < data_length) {
                 async_data_read_finalize(callid, data, length);
@@ -216 +263 @@
         }
 
-        /* Send the data */
+        // send the data
         return async_data_read_finalize(callid, data, data_length);
 }
 
-/** Refresh answer structure and argument count.
- *
- * Erase all arguments.
- *
- * @param[in,out] answer Message processing answer structure.
- * @param[in,out] count  Number of answer arguments.
- *
- */
-void refresh_answer(ipc_call_t *answer, size_t *count)
-{
-        if (count != NULL)
-                *count = 0;
-        
-        if (answer != NULL) {
+/** Refreshes answer structure and parameters count.
+ *
+ * Erases all attributes.
+ *
+ * @param[in,out] answer The message processing answer structure.
+ * @param[in,out] answer_count The number of answer parameters.
+ */
+void refresh_answer(ipc_call_t *answer, int *answer_count)
+{
+        if (answer_count)
+                *answer_count = 0;
+
+        if (answer) {
                 IPC_SET_RETVAL(*answer, 0);
-                IPC_SET_IMETHOD(*answer, 0);
+                // just to be precize
+                IPC_SET_METHOD(*answer, 0);
                 IPC_SET_ARG1(*answer, 0);
                 IPC_SET_ARG2(*answer, 0);