Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/netif/lo/lo.c

    r46d4d9f rf5a3479  
    2828
    2929/** @addtogroup lo
    30  * @{
     30 *  @{
    3131 */
    3232
    3333/** @file
    34  * Loopback network interface implementation.
     34 *  Loopback network interface implementation.
    3535 */
    3636
    3737#include <async.h>
    3838#include <errno.h>
     39#include <err.h>
    3940#include <stdio.h>
    4041#include <str.h>
     
    5253#include <netif_local.h>
    5354
    54 /** Default hardware address. */
     55/** Default hardware address.
     56 */
    5557#define DEFAULT_ADDR            "\0\0\0\0\0\0"
    5658
    57 /** Default address length. */
     59/** Default address length.
     60 */
    5861#define DEFAULT_ADDR_LEN        (sizeof(DEFAULT_ADDR) / sizeof(char))
    5962
    60 /** Loopback module name. */
     63/** Loopback module name.
     64 */
    6165#define NAME  "lo"
    6266
    63 /** Network interface global data. */
     67/** Network interface global data.
     68 */
    6469netif_globals_t netif_globals;
    6570
    66 int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
    67     ipc_call_t *answer, int *answer_count)
    68 {
     71/** Changes the loopback state.
     72 *  @param[in] device The device structure.
     73 *  @param[in] state The new device state.
     74 *  @returns The new state if changed.
     75 *  @returns EOK otherwise.
     76 */
     77int change_state_message(netif_device_t * device, device_state_t state);
     78
     79/** Creates and returns the loopback network interface structure.
     80 *  @param[in] device_id The new devce identifier.
     81 *  @param[out] device The device structure.
     82 *  @returns EOK on success.
     83 *  @returns EXDEV if one loopback network interface already exists.
     84 *  @returns ENOMEM if there is not enough memory left.
     85 */
     86int create(device_id_t device_id, netif_device_t * * device);
     87
     88int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    6989        return ENOTSUP;
    7090}
    7191
    72 int netif_get_addr_message(device_id_t device_id, measured_string_t *address)
    73 {
    74         if (!address)
     92int netif_get_addr_message(device_id_t device_id, measured_string_ref address){
     93        if(! address){
    7594                return EBADMEM;
    76 
     95        }
    7796        address->value = str_dup(DEFAULT_ADDR);
    7897        address->length = DEFAULT_ADDR_LEN;
    79 
    80         return EOK;
    81 }
    82 
    83 int netif_get_device_stats(device_id_t device_id, device_stats_t *stats)
    84 {
    85         netif_device_t *device;
    86         int rc;
    87 
    88         if (!stats)
     98        return EOK;
     99}
     100
     101int netif_get_device_stats(device_id_t device_id, device_stats_ref stats){
     102        ERROR_DECLARE;
     103
     104        netif_device_t * device;
     105
     106        if(! stats){
    89107                return EBADMEM;
    90 
    91         rc = find_device(device_id, &device);
    92         if (rc != EOK)
    93                 return rc;
    94 
    95         memcpy(stats, (device_stats_t *) device->specific,
    96             sizeof(device_stats_t));
    97 
    98         return EOK;
    99 }
    100 
    101 /** Changes the loopback state.
    102  *
    103  * @param[in] device    The device structure.
    104  * @param[in] state     The new device state.
    105  * @return              The new state if changed.
    106  * @return              EOK otherwise.
    107  */
    108 static int change_state_message(netif_device_t *device, device_state_t state)
     108        }
     109        ERROR_PROPAGATE(find_device(device_id, &device));
     110        memcpy(stats, (device_stats_ref) device->specific, sizeof(device_stats_t));
     111        return EOK;
     112}
     113
     114int change_state_message(netif_device_t * device, device_state_t state)
    109115{
    110116        if (device->state != state) {
     
    120126}
    121127
    122 /** Creates and returns the loopback network interface structure.
    123  *
    124  * @param[in] device_id The new devce identifier.
    125  * @param[out] device   The device structure.
    126  * @return              EOK on success.
    127  * @return              EXDEV if one loopback network interface already exists.
    128  * @return              ENOMEM if there is not enough memory left.
    129  */
    130 static int create(device_id_t device_id, netif_device_t **device)
    131 {
     128int create(device_id_t device_id, netif_device_t * * device){
    132129        int index;
    133130
    134         if (netif_device_map_count(&netif_globals.device_map) > 0)
     131        if(netif_device_map_count(&netif_globals.device_map) > 0){
    135132                return EXDEV;
    136 
    137         *device = (netif_device_t *) malloc(sizeof(netif_device_t));
    138         if (!*device)
    139                 return ENOMEM;
    140 
    141         (*device)->specific = (device_stats_t *) malloc(sizeof(device_stats_t));
    142         if (!(*device)->specific) {
    143                 free(*device);
    144                 return ENOMEM;
    145         }
    146 
    147         null_device_stats((device_stats_t *) (*device)->specific);
    148         (*device)->device_id = device_id;
    149         (*device)->nil_phone = -1;
    150         (*device)->state = NETIF_STOPPED;
    151         index = netif_device_map_add(&netif_globals.device_map,
    152             (*device)->device_id, *device);
    153 
    154         if (index < 0) {
    155                 free(*device);
    156                 free((*device)->specific);
    157                 *device = NULL;
    158                 return index;
    159         }
    160        
    161         return EOK;
    162 }
    163 
    164 int netif_initialize(void)
    165 {
     133        }else{
     134                *device = (netif_device_t *) malloc(sizeof(netif_device_t));
     135                if(!(*device)){
     136                        return ENOMEM;
     137                }
     138                (** device).specific = malloc(sizeof(device_stats_t));
     139                if(! (** device).specific){
     140                        free(*device);
     141                        return ENOMEM;
     142                }
     143                null_device_stats((device_stats_ref)(** device).specific);
     144                (** device).device_id = device_id;
     145                (** device).nil_phone = -1;
     146                (** device).state = NETIF_STOPPED;
     147                index = netif_device_map_add(&netif_globals.device_map, (** device).device_id, * device);
     148                if(index < 0){
     149                        free(*device);
     150                        free((** device).specific);
     151                        *device = NULL;
     152                        return index;
     153                }
     154        }
     155        return EOK;
     156}
     157
     158int netif_initialize(void){
    166159        ipcarg_t phonehash;
    167160
     
    169162}
    170163
    171 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
    172 {
    173         netif_device_t *device;
    174         int rc;
    175 
    176         /* Create a new device */
    177         rc = create(device_id, &device);
    178         if (rc != EOK)
    179                 return rc;
    180 
    181         /* Print the settings */
     164int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
     165        ERROR_DECLARE;
     166
     167        netif_device_t * device;
     168
     169        // create a new device
     170        ERROR_PROPAGATE(create(device_id, &device));
     171        // print the settings
    182172        printf("%s: Device created (id: %d)\n", NAME, device->device_id);
    183 
    184         return EOK;
    185 }
    186 
    187 int netif_send_message(device_id_t device_id, packet_t *packet, services_t sender)
    188 {
    189         netif_device_t *device;
     173        return EOK;
     174}
     175
     176int netif_send_message(device_id_t device_id, packet_t packet, services_t sender){
     177        ERROR_DECLARE;
     178
     179        netif_device_t * device;
    190180        size_t length;
    191         packet_t *next;
     181        packet_t next;
    192182        int phone;
    193         int rc;
    194 
    195         rc = find_device(device_id, &device);
    196         if (rc != EOK)
    197                 return EOK;
    198 
    199         if (device->state != NETIF_ACTIVE) {
     183
     184        ERROR_PROPAGATE(find_device(device_id, &device));
     185        if(device->state != NETIF_ACTIVE){
    200186                netif_pq_release(packet_get_id(packet));
    201187                return EFORWARD;
    202188        }
    203 
    204189        next = packet;
    205         do {
    206                 ((device_stats_t *) device->specific)->send_packets++;
    207                 ((device_stats_t *) device->specific)->receive_packets++;
     190        do{
     191                ++ ((device_stats_ref) device->specific)->send_packets;
     192                ++ ((device_stats_ref) device->specific)->receive_packets;
    208193                length = packet_get_data_length(next);
    209                 ((device_stats_t *) device->specific)->send_bytes += length;
    210                 ((device_stats_t *) device->specific)->receive_bytes += length;
     194                ((device_stats_ref) device->specific)->send_bytes += length;
     195                ((device_stats_ref) device->specific)->receive_bytes += length;
    211196                next = pq_next(next);
    212         } while(next);
    213 
     197        }while(next);
    214198        phone = device->nil_phone;
    215199        fibril_rwlock_write_unlock(&netif_globals.lock);
    216200        nil_received_msg(phone, device_id, packet, sender);
    217201        fibril_rwlock_write_lock(&netif_globals.lock);
    218        
    219         return EOK;
    220 }
    221 
    222 int netif_start_message(netif_device_t *device)
    223 {
     202        return EOK;
     203}
     204
     205int netif_start_message(netif_device_t * device){
    224206        return change_state_message(device, NETIF_ACTIVE);
    225207}
    226208
    227 int netif_stop_message(netif_device_t *device)
    228 {
     209int netif_stop_message(netif_device_t * device){
    229210        return change_state_message(device, NETIF_STOPPED);
    230211}
     
    232213/** Default thread for new connections.
    233214 *
    234  * @param[in] iid       The initial message identifier.
    235  * @param[in] icall     The initial message call structure.
     215 * @param[in] iid The initial message identifier.
     216 * @param[in] icall The initial message call structure.
     217 *
    236218 */
    237219static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     
    243225        ipc_answer_0(iid, EOK);
    244226       
    245         while (true) {
     227        while(true) {
    246228                ipc_call_t answer;
    247229                int answer_count;
     
    258240                    &answer_count);
    259241               
    260                 /*
    261                  * End if told to either by the message or the processing
    262                  * result.
    263                  */
    264                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
    265                     (res == EHANGUP))
     242                /* End if said to either by the message or the processing result */
     243                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
    266244                        return;
    267245               
     
    273251int main(int argc, char *argv[])
    274252{
    275         int rc;
     253        ERROR_DECLARE;
    276254       
    277255        /* Start the module */
    278         rc = netif_module_start(netif_client_connection);
    279         return rc;
     256        if (ERROR_OCCURRED(netif_module_start(netif_client_connection)))
     257                return ERROR_CODE;
     258       
     259        return EOK;
    280260}
    281261
Note: See TracChangeset for help on using the changeset viewer.