Changeset eb522e8 in mainline for uspace/srv/net/netif/lo/lo.c

Timestamp:

2011-06-01T08:43:42Z (14 years ago)

Author:

Lubos Slovak <lubos.slovak@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

8d6c1f1

Parents:

9e2e715 (diff), e51a514 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Huuuuuge merge from development - all the work actually

File:

• uspace/srv/net/netif/lo/lo.c (modified) (4 diffs)

uspace/srv/net/netif/lo/lo.c

@@ -39 +39 @@
 #include <stdio.h>
 #include <str.h>
-
-#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/nil.h>
-
 #include <net/modules.h>
 #include <adt/measured_strings.h>
 #include <packet_client.h>
 #include <net/device.h>
-#include <nil_interface.h>
-#include <netif_interface.h>
-#include <netif_local.h>
-
-/** Default hardware address. */
-#define DEFAULT_ADDR            "\0\0\0\0\0\0"
+#include <netif_skel.h>
+#include <nil_remote.h>
 
 /** Default address length. */
-#define DEFAULT_ADDR_LEN        (sizeof(DEFAULT_ADDR) / sizeof(char))
+#define DEFAULT_ADDR_LEN  6
 
 /** Loopback module name. */
 #define NAME  "lo"
 
-/** Network interface global data. */
-netif_globals_t netif_globals;
+static uint8_t default_addr[DEFAULT_ADDR_LEN] =
+    {0, 0, 0, 0, 0, 0};
 
 int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
 {
         return ENOTSUP;
 }
 
-int netif_get_addr_message(device_id_t device_id, measured_string_ref address)
+int netif_get_addr_message(device_id_t device_id, measured_string_t *address)
 {
         if (!address)
                 return EBADMEM;
-
-        address->value = str_dup(DEFAULT_ADDR);
+        
+        address->value = default_addr;
         address->length = DEFAULT_ADDR_LEN;
-
-        return EOK;
-}
-
-int netif_get_device_stats(device_id_t device_id, device_stats_ref stats)
-{
-        netif_device_t *device;
-        int rc;
-
+        
+        return EOK;
+}
+
+int netif_get_device_stats(device_id_t device_id, device_stats_t *stats)
+{
         if (!stats)
                 return EBADMEM;
-
-        rc = find_device(device_id, &device);
+        
+        netif_device_t *device;
+        int rc = find_device(device_id, &device);
         if (rc != EOK)
                 return rc;
-
-        memcpy(stats, (device_stats_ref) device->specific,
+        
+        memcpy(stats, (device_stats_t *) device->specific,
             sizeof(device_stats_t));
-
-        return EOK;
-}
-
-/** Changes the loopback state.
- *
- * @param[in] device    The device structure.
- * @param[in] state     The new device state.
- * @returns             The new state if changed.
- * @returns             EOK otherwise.
- */
-static int change_state_message(netif_device_t *device, device_state_t state)
+        
+        return EOK;
+}
+
+/** Change the loopback state.
+ *
+ * @param[in] device The device structure.
+ * @param[in] state  The new device state.
+ *
+ * @return New state if changed.
+ * @return EOK otherwise.
+ *
+ */
+static void change_state_message(netif_device_t *device, device_state_t state)
 {
         if (device->state != state) {
                 device->state = state;
                 
-                printf("%s: State changed to %s\n", NAME,
-                    (state == NETIF_ACTIVE) ? "active" : "stopped");
+                const char *desc;
+                switch (state) {
+                case NETIF_ACTIVE:
+                        desc = "active";
+                        break;
+                case NETIF_STOPPED:
+                        desc = "stopped";
+                        break;
+                default:
+                        desc = "unknown";
+                }
                 
-                return state;
-        }
-        
-        return EOK;
-}
-
-/** Creates and returns the loopback network interface structure.
- *
- * @param[in] device_id The new devce identifier.
- * @param[out] device   The device structure.
- * @returns             EOK on success.
- * @returns             EXDEV if one loopback network interface already exists.
- * @returns             ENOMEM if there is not enough memory left.
- */
-static int create(device_id_t device_id, netif_device_t **device)
-{
-        int index;
-
+                printf("%s: State changed to %s\n", NAME, desc);
+        }
+}
+
+/** Create and return the loopback network interface structure.
+ *
+ * @param[in]  device_id New devce identifier.
+ * @param[out] device    Device structure.
+ *
+ * @return EOK on success.
+ * @return EXDEV if one loopback network interface already exists.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+static int lo_create(device_id_t device_id, netif_device_t **device)
+{
         if (netif_device_map_count(&netif_globals.device_map) > 0)
                 return EXDEV;
-
+        
         *device = (netif_device_t *) malloc(sizeof(netif_device_t));
         if (!*device)
                 return ENOMEM;
-
+        
         (*device)->specific = (device_stats_t *) malloc(sizeof(device_stats_t));
         if (!(*device)->specific) {
@@ -144 +144 @@
                 return ENOMEM;
         }
-
-        null_device_stats((device_stats_ref) (*device)->specific);
+        
+        null_device_stats((device_stats_t *) (*device)->specific);
         (*device)->device_id = device_id;
         (*device)->nil_phone = -1;
         (*device)->state = NETIF_STOPPED;
-        index = netif_device_map_add(&netif_globals.device_map,
+        int index = netif_device_map_add(&netif_globals.device_map,
             (*device)->device_id, *device);
-
+        
         if (index < 0) {
                 free(*device);
@@ -164 +164 @@
 int netif_initialize(void)
 {
-        ipcarg_t phonehash;
-
-        return REGISTER_ME(SERVICE_LO, &phonehash);
-}
-
-int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
-{
+        return async_connect_to_me(PHONE_NS, SERVICE_LO, 0, 0, NULL);
+}
+
+int netif_probe_message(device_id_t device_id, int irq, void *io)
+{
+        /* Create a new device */
         netif_device_t *device;
-        int rc;
-
-        /* Create a new device */
-        rc = create(device_id, &device);
+        int rc = lo_create(device_id, &device);
         if (rc != EOK)
                 return rc;
-
-        /* Print the settings */
+        
         printf("%s: Device created (id: %d)\n", NAME, device->device_id);
-
-        return EOK;
-}
-
-int netif_send_message(device_id_t device_id, packet_t packet, services_t sender)
+        return EOK;
+}
+
+int netif_send_message(device_id_t device_id, packet_t *packet, services_t sender)
 {
         netif_device_t *device;
-        size_t length;
-        packet_t next;
-        int phone;
-        int rc;
-
-        rc = find_device(device_id, &device);
+        int rc = find_device(device_id, &device);
         if (rc != EOK)
                 return EOK;
-
+        
         if (device->state != NETIF_ACTIVE) {
                 netif_pq_release(packet_get_id(packet));
                 return EFORWARD;
         }
-
-        next = packet;
+        
+        packet_t *next = packet;
         do {
-                ((device_stats_ref) device->specific)->send_packets++;
-                ((device_stats_ref) device->specific)->receive_packets++;
-                length = packet_get_data_length(next);
-                ((device_stats_ref) device->specific)->send_bytes += length;
-                ((device_stats_ref) device->specific)->receive_bytes += length;
+                ((device_stats_t *) device->specific)->send_packets++;
+                ((device_stats_t *) device->specific)->receive_packets++;
+                size_t length = packet_get_data_length(next);
+                ((device_stats_t *) device->specific)->send_bytes += length;
+                ((device_stats_t *) device->specific)->receive_bytes += length;
                 next = pq_next(next);
-        } while(next);
-
-        phone = device->nil_phone;
+        } while (next);
+        
+        int phone = device->nil_phone;
         fibril_rwlock_write_unlock(&netif_globals.lock);
+        
         nil_received_msg(phone, device_id, packet, sender);
+        
         fibril_rwlock_write_lock(&netif_globals.lock);
-        
         return EOK;
 }
@@ -222 +212 @@
 int netif_start_message(netif_device_t *device)
 {
-        return change_state_message(device, NETIF_ACTIVE);
+        change_state_message(device, NETIF_ACTIVE);
+        return device->state;
 }
 
 int netif_stop_message(netif_device_t *device)
 {
-        return change_state_message(device, NETIF_STOPPED);
-}
-
-/** Default thread for new connections.
- *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
-{
-        /*
-         * Accept the connection
-         *  - Answer the first IPC_M_CONNECT_ME_TO call.
-         */
-        ipc_answer_0(iid, EOK);
-        
-        while (true) {
-                ipc_call_t answer;
-                int answer_count;
-                
-                /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
-                
-                /* Fetch the next message */
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                
-                /* Process the message */
-                int res = netif_module_message(NAME, callid, &call, &answer,
-                    &answer_count);
-                
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
-        }
+        change_state_message(device, NETIF_STOPPED);
+        return device->state;
 }
 
 int main(int argc, char *argv[])
 {
-        int rc;
-        
         /* Start the module */
-        rc = netif_module_start(netif_client_connection);
-        return rc;
+        return netif_module_start();
 }