Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset e7f6389 in mainline


Ignore:
Timestamp:
2010-10-26T22:45:19Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
f2d2c604
Parents:
e503d3a9 (diff), 3cd95ef (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:

Merge from lp:~jakub/helenos/net.

Location:
uspace/srv/net
Files:
2 edited

Legend:

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

    re503d3a9 re7f6389  
    2828
    2929/** @addtogroup lo
    30  *  @{
     30 * @{
    3131 */
    3232
    3333/** @file
    34  *  Loopback network interface implementation.
     34 * Loopback network interface implementation.
    3535 */
    3636
     
    5353#include <netif_local.h>
    5454
    55 /** Default hardware address.
    56  */
     55/** Default hardware address. */
    5756#define DEFAULT_ADDR            "\0\0\0\0\0\0"
    5857
    59 /** Default address length.
    60  */
     58/** Default address length. */
    6159#define DEFAULT_ADDR_LEN        (sizeof(DEFAULT_ADDR) / sizeof(char))
    6260
    63 /** Loopback module name.
    64  */
     61/** Loopback module name. */
    6562#define NAME  "lo"
    6663
    67 /** Network interface global data.
    68  */
     64/** Network interface global data. */
    6965netif_globals_t netif_globals;
    7066
    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  */
    77 int 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  */
    86 int create(device_id_t device_id, netif_device_t * * device);
    87 
    88 int netif_specific_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     67int
     68netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
     69    ipc_call_t *answer, int *answer_count)
     70{
    8971        return ENOTSUP;
    9072}
    9173
    92 int netif_get_addr_message(device_id_t device_id, measured_string_ref address){
    93         if(! address){
     74int netif_get_addr_message(device_id_t device_id, measured_string_ref address)
     75{
     76        if (!address)
    9477                return EBADMEM;
    95         }
    9678        address->value = str_dup(DEFAULT_ADDR);
    9779        address->length = DEFAULT_ADDR_LEN;
     
    9981}
    10082
    101 int 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){
     83int netif_get_device_stats(device_id_t device_id, device_stats_ref stats)
     84{
     85        ERROR_DECLARE;
     86
     87        netif_device_t *device;
     88
     89        if (!stats)
    10790                return EBADMEM;
    108         }
    10991        ERROR_PROPAGATE(find_device(device_id, &device));
    110         memcpy(stats, (device_stats_ref) device->specific, sizeof(device_stats_t));
    111         return EOK;
    112 }
    113 
    114 int change_state_message(netif_device_t * device, device_state_t state)
     92        memcpy(stats, (device_stats_ref) device->specific,
     93            sizeof(device_stats_t));
     94        return EOK;
     95}
     96
     97/** Changes the loopback state.
     98 *
     99 * @param[in] device    The device structure.
     100 * @param[in] state     The new device state.
     101 * @returns             The new state if changed.
     102 * @returns             EOK otherwise.
     103 */
     104static int change_state_message(netif_device_t *device, device_state_t state)
    115105{
    116106        if (device->state != state) {
     
    126116}
    127117
    128 int create(device_id_t device_id, netif_device_t * * device){
     118/** Creates and returns the loopback network interface structure.
     119 *
     120 * @param[in] device_id The new devce identifier.
     121 * @param[out] device   The device structure.
     122 * @returns             EOK on success.
     123 * @returns             EXDEV if one loopback network interface already exists.
     124 * @returns             ENOMEM if there is not enough memory left.
     125 */
     126static int create(device_id_t device_id, netif_device_t **device)
     127{
    129128        int index;
    130129
    131         if(netif_device_map_count(&netif_globals.device_map) > 0){
     130        if (netif_device_map_count(&netif_globals.device_map) > 0)
    132131                return EXDEV;
    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 
    158 int netif_initialize(void){
     132
     133        *device = (netif_device_t *) malloc(sizeof(netif_device_t));
     134        if (!*device)
     135                return ENOMEM;
     136        (*device)->specific = (device_stats_t *) malloc(sizeof(device_stats_t));
     137        if (!(*device)->specific) {
     138                free(*device);
     139                return ENOMEM;
     140        }
     141        null_device_stats((device_stats_ref) (*device)->specific);
     142        (*device)->device_id = device_id;
     143        (*device)->nil_phone = -1;
     144        (*device)->state = NETIF_STOPPED;
     145        index = netif_device_map_add(&netif_globals.device_map,
     146            (*device)->device_id, *device);
     147        if (index < 0) {
     148                free(*device);
     149                free((*device)->specific);
     150                *device = NULL;
     151                return index;
     152        }
     153       
     154        return EOK;
     155}
     156
     157int netif_initialize(void)
     158{
    159159        ipcarg_t phonehash;
    160160
     
    162162}
    163163
    164 int netif_probe_message(device_id_t device_id, int irq, uintptr_t io){
    165         ERROR_DECLARE;
    166 
    167         netif_device_t * device;
     164int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
     165{
     166        ERROR_DECLARE;
     167
     168        netif_device_t *device;
    168169
    169170        // create a new device
     
    174175}
    175176
    176 int netif_send_message(device_id_t device_id, packet_t packet, services_t sender){
    177         ERROR_DECLARE;
    178 
    179         netif_device_t * device;
     177int netif_send_message(device_id_t device_id, packet_t packet, services_t sender)
     178{
     179        ERROR_DECLARE;
     180
     181        netif_device_t *device;
    180182        size_t length;
    181183        packet_t next;
     
    183185
    184186        ERROR_PROPAGATE(find_device(device_id, &device));
    185         if(device->state != NETIF_ACTIVE){
     187        if (device->state != NETIF_ACTIVE) {
    186188                netif_pq_release(packet_get_id(packet));
    187189                return EFORWARD;
    188190        }
    189191        next = packet;
    190         do{
    191                 ++ ((device_stats_ref) device->specific)->send_packets;
    192                 ++ ((device_stats_ref) device->specific)->receive_packets;
     192        do {
     193                ((device_stats_ref) device->specific)->send_packets++;
     194                ((device_stats_ref) device->specific)->receive_packets++;
    193195                length = packet_get_data_length(next);
    194196                ((device_stats_ref) device->specific)->send_bytes += length;
    195197                ((device_stats_ref) device->specific)->receive_bytes += length;
    196198                next = pq_next(next);
    197         }while(next);
     199        } while(next);
    198200        phone = device->nil_phone;
    199201        fibril_rwlock_write_unlock(&netif_globals.lock);
    200202        nil_received_msg(phone, device_id, packet, sender);
    201203        fibril_rwlock_write_lock(&netif_globals.lock);
    202         return EOK;
    203 }
    204 
    205 int netif_start_message(netif_device_t * device){
     204       
     205        return EOK;
     206}
     207
     208int netif_start_message(netif_device_t *device)
     209{
    206210        return change_state_message(device, NETIF_ACTIVE);
    207211}
    208212
    209 int netif_stop_message(netif_device_t * device){
     213int netif_stop_message(netif_device_t *device)
     214{
    210215        return change_state_message(device, NETIF_STOPPED);
    211216}
     
    213218/** Default thread for new connections.
    214219 *
    215  * @param[in] iid The initial message identifier.
    216  * @param[in] icall The initial message call structure.
    217  *
     220 * @param[in] iid       The initial message identifier.
     221 * @param[in] icall     The initial message call structure.
    218222 */
    219223static void netif_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     
    225229        ipc_answer_0(iid, EOK);
    226230       
    227         while(true) {
     231        while (true) {
    228232                ipc_call_t answer;
    229233                int answer_count;
     
    240244                    &answer_count);
    241245               
    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))
     246                /*
     247                 * End if told to either by the message or the processing
     248                 * result.
     249                 */
     250                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     251                    (res == EHANGUP))
    244252                        return;
    245253               
     
    254262       
    255263        /* Start the module */
    256         if (ERROR_OCCURRED(netif_module_start(netif_client_connection)))
    257                 return ERROR_CODE;
    258        
     264        ERROR_PROPAGATE(netif_module_start(netif_client_connection));
    259265        return EOK;
    260266}
  • uspace/srv/net/nil/nildummy/nildummy.c

    re503d3a9 re7f6389  
    5858#include "nildummy.h"
    5959
    60 /** The module name.
    61  *
    62  */
     60/** The module name. */
    6361#define NAME  "nildummy"
    6462
    65 /** Default maximum transmission unit.
    66  *
    67  */
     63/** Default maximum transmission unit. */
    6864#define NET_DEFAULT_MTU  1500
    6965
    70 /** Network interface layer module global data.
    71  *
    72  */
     66/** Network interface layer module global data. */
    7367nildummy_globals_t nildummy_globals;
    7468
     
    7872{
    7973        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    80        
    8174        if (nildummy_globals.proto.phone)
    82                 il_device_state_msg(nildummy_globals.proto.phone, device_id, state,
    83                     nildummy_globals.proto.service);
    84        
     75                il_device_state_msg(nildummy_globals.proto.phone, device_id,
     76                    state, nildummy_globals.proto.service);
    8577        fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
    8678       
     
    9991        nildummy_globals.net_phone = net_phone;
    10092        nildummy_globals.proto.phone = 0;
    101         ERROR_PROPAGATE(nildummy_devices_initialize(&nildummy_globals.devices));
     93        ERROR_CODE = nildummy_devices_initialize(&nildummy_globals.devices);
    10294       
    10395        fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
    10496        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    10597       
    106         return EOK;
    107 }
    108 
    109 /** Process IPC messages from the registered device driver modules in an infinite loop.
    110  *
    111  * @param[in]     iid   The message identifier.
    112  * @param[in,out] icall The message parameters.
    113  *
    114  */
    115 static void nildummy_receiver(ipc_callid_t iid, ipc_call_t * icall){
     98        return ERROR_CODE;
     99}
     100
     101/** Process IPC messages from the registered device driver modules in an
     102 * infinite loop.
     103 *
     104 * @param[in] iid       The message identifier.
     105 * @param[in,out]       icall The message parameters.
     106 */
     107static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall)
     108{
    116109        ERROR_DECLARE;
    117110
    118111        packet_t packet;
    119112
    120         while(true){
    121                 switch(IPC_GET_METHOD(*icall)){
    122                         case NET_NIL_DEVICE_STATE:
    123                                 ERROR_CODE = nil_device_state_msg_local(0, IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
    124                                 ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
    125                                 break;
    126                         case NET_NIL_RECEIVED:
    127                                 if(! ERROR_OCCURRED(packet_translate_remote(nildummy_globals.net_phone, &packet, IPC_GET_PACKET(icall)))){
    128                                         ERROR_CODE = nil_received_msg_local(0, IPC_GET_DEVICE(icall), packet, 0);
    129                                 }
    130                                 ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
    131                                 break;
    132                         default:
    133                                 ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
     113        while (true) {
     114                switch (IPC_GET_METHOD(*icall)) {
     115                case NET_NIL_DEVICE_STATE:
     116                        ERROR_CODE = nil_device_state_msg_local(0,
     117                            IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
     118                        ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
     119                        break;
     120               
     121                case NET_NIL_RECEIVED:
     122                        if (ERROR_NONE(packet_translate_remote(
     123                            nildummy_globals.net_phone, &packet,
     124                            IPC_GET_PACKET(icall)))) {
     125                                ERROR_CODE = nil_received_msg_local(0,
     126                                    IPC_GET_DEVICE(icall), packet, 0);
     127                        }
     128                        ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
     129                        break;
     130               
     131                default:
     132                        ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
    134133                }
     134               
    135135                iid = async_get_call(icall);
    136136        }
     
    141141 * Determine the device local hardware address.
    142142 *
    143  * @param[in] device_id The new device identifier.
    144  * @param[in] service   The device driver service.
    145  * @param[in] mtu       The device maximum transmission unit.
    146  *
    147  * @returns EOK on success.
    148  * @returns EEXIST if the device with the different service exists.
    149  * @returns ENOMEM if there is not enough memory left.
    150  * @returns Other error codes as defined for the netif_bind_service() function.
    151  * @returns Other error codes as defined for the netif_get_addr_req() function.
    152  *
    153  */
    154 static int nildummy_device_message(device_id_t device_id, services_t service,
    155     size_t mtu)
     143 * @param[in] device_id The new device identifier.
     144 * @param[in] service   The device driver service.
     145 * @param[in] mtu       The device maximum transmission unit.
     146 * @returns             EOK on success.
     147 * @returns             EEXIST if the device with the different service exists.
     148 * @returns             ENOMEM if there is not enough memory left.
     149 * @returns             Other error codes as defined for the
     150 *                      netif_bind_service() function.
     151 * @returns             Other error codes as defined for the
     152 *                      netif_get_addr_req() function.
     153 */
     154static int
     155nildummy_device_message(device_id_t device_id, services_t service, size_t mtu)
    156156{
    157157        ERROR_DECLARE;
     
    161161
    162162        fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
     163
    163164        // an existing device?
    164165        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
    165         if(device){
    166                 if(device->service != service){
     166        if (device) {
     167                if (device->service != service) {
    167168                        printf("Device %d already exists\n", device->device_id);
    168                         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     169                        fibril_rwlock_write_unlock(
     170                            &nildummy_globals.devices_lock);
    169171                        return EEXIST;
    170                 }else{
    171                         // update mtu
    172                         if(mtu > 0){
    173                                 device->mtu = mtu;
    174                         }else{
    175                                 device->mtu = NET_DEFAULT_MTU;
    176                         }
    177                         printf("Device %d already exists:\tMTU\t= %d\n", device->device_id, device->mtu);
    178                         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    179                         // notify the upper layer module
    180                         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    181                         if(nildummy_globals.proto.phone){
    182                                 il_mtu_changed_msg(nildummy_globals.proto.phone, device->device_id, device->mtu, nildummy_globals.proto.service);
    183                         }
    184                         fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
    185                         return EOK;
    186172                }
    187         }else{
    188                 // create a new device
    189                 device = (nildummy_device_ref) malloc(sizeof(nildummy_device_t));
    190                 if(! device){
    191                         return ENOMEM;
     173               
     174                // update mtu
     175                if (mtu > 0)
     176                        device->mtu = mtu;
     177                else
     178                        device->mtu = NET_DEFAULT_MTU;
     179               
     180                printf("Device %d already exists:\tMTU\t= %d\n",
     181                    device->device_id, device->mtu);
     182                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     183               
     184                // notify the upper layer module
     185                fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
     186                if (nildummy_globals.proto.phone) {
     187                        il_mtu_changed_msg(nildummy_globals.proto.phone,
     188                            device->device_id, device->mtu,
     189                            nildummy_globals.proto.service);
    192190                }
    193                 device->device_id = device_id;
    194                 device->service = service;
    195                 if(mtu > 0){
    196                         device->mtu = mtu;
    197                 }else{
    198                         device->mtu = NET_DEFAULT_MTU;
    199                 }
    200                 // bind the device driver
    201                 device->phone = netif_bind_service(device->service, device->device_id, SERVICE_ETHERNET, nildummy_receiver);
    202                 if(device->phone < 0){
    203                         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    204                         free(device);
    205                         return device->phone;
    206                 }
    207                 // get hardware address
    208                 if(ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id, &device->addr, &device->addr_data))){
    209                         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    210                         free(device);
    211                         return ERROR_CODE;
    212                 }
    213                 // add to the cache
    214                 index = nildummy_devices_add(&nildummy_globals.devices, device->device_id, device);
    215                 if(index < 0){
    216                         fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    217                         free(device->addr);
    218                         free(device->addr_data);
    219                         free(device);
    220                         return index;
    221                 }
    222                 printf("%s: Device registered (id: %d, service: %d, mtu: %d)\n",
    223                     NAME, device->device_id, device->service, device->mtu);
    224         }
     191                fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
     192               
     193                return EOK;
     194        }
     195       
     196        // create a new device
     197        device = (nildummy_device_ref) malloc(sizeof(nildummy_device_t));
     198        if (!device)
     199                return ENOMEM;
     200       
     201        device->device_id = device_id;
     202        device->service = service;
     203        if (mtu > 0)
     204                device->mtu = mtu;
     205        else
     206                device->mtu = NET_DEFAULT_MTU;
     207
     208        // bind the device driver
     209        device->phone = netif_bind_service(device->service, device->device_id,
     210            SERVICE_ETHERNET, nildummy_receiver);
     211        if (device->phone < 0) {
     212                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     213                free(device);
     214                return device->phone;
     215        }
     216       
     217        // get hardware address
     218        if (ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id,
     219            &device->addr, &device->addr_data))) {
     220                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     221                free(device);
     222                return ERROR_CODE;
     223        }
     224       
     225        // add to the cache
     226        index = nildummy_devices_add(&nildummy_globals.devices,
     227            device->device_id, device);
     228        if (index < 0) {
     229                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
     230                free(device->addr);
     231                free(device->addr_data);
     232                free(device);
     233                return index;
     234        }
     235       
     236        printf("%s: Device registered (id: %d, service: %d, mtu: %d)\n",
     237            NAME, device->device_id, device->service, device->mtu);
    225238        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    226239        return EOK;
     
    229242/** Return the device hardware address.
    230243 *
    231  * @param[in]  device_id The device identifier.
    232  * @param[out] address   The device hardware address.
    233  *
    234  * @return EOK on success.
    235  * @return EBADMEM if the address parameter is NULL.
    236  * @return ENOENT if there no such device.
    237  *
    238  */
    239 static int nildummy_addr_message(device_id_t device_id,
    240     measured_string_ref *address)
     244 * @param[in] device_id The device identifier.
     245 * @param[out] address  The device hardware address.
     246 * @return               EOK on success.
     247 * @return              EBADMEM if the address parameter is NULL.
     248 * @return              ENOENT if there no such device.
     249 *
     250 */
     251static int
     252nildummy_addr_message(device_id_t device_id, measured_string_ref *address)
    241253{
    242254        nildummy_device_ref device;
    243255
    244         if(! address){
     256        if (!address)
    245257                return EBADMEM;
    246         }
     258       
    247259        fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
    248260        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
    249         if(! device){
     261        if (!device) {
    250262                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    251263                return ENOENT;
     
    253265        *address = device->addr;
    254266        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
     267       
    255268        return (*address) ? EOK : ENOENT;
    256269}
     
    258271/** Return the device packet dimensions for sending.
    259272 *
    260  * @param[in]  device_id The device identifier.
    261  * @param[out] addr_len  The minimum reserved address length.
    262  * @param[out] prefix    The minimum reserved prefix size.
    263  * @param[out] content   The maximum content size.
    264  * @param[out] suffix    The minimum reserved suffix size.
    265  *
    266  * @return EOK on success.
    267  * @return EBADMEM if either one of the parameters is NULL.
    268  * @return ENOENT if there is no such device.
    269  *
    270  */
    271 static int nildummy_packet_space_message(device_id_t device_id,
    272     size_t *addr_len, size_t *prefix, size_t *content, size_t *suffix)
     273 * @param[in] device_id The device identifier.
     274 * @param[out] addr_len The minimum reserved address length.
     275 * @param[out] prefix   The minimum reserved prefix size.
     276 * @param[out] content  The maximum content size.
     277 * @param[out] suffix   The minimum reserved suffix size.
     278 * @return              EOK on success.
     279 * @return              EBADMEM if either one of the parameters is NULL.
     280 * @return              ENOENT if there is no such device.
     281 *
     282 */
     283static int
     284nildummy_packet_space_message(device_id_t device_id, size_t *addr_len,
     285    size_t *prefix, size_t *content, size_t *suffix)
    273286{
    274287        nildummy_device_ref device;
    275288
    276         if(!(addr_len && prefix && content && suffix)){
     289        if (!addr_len || !prefix || !content || !suffix)
    277290                return EBADMEM;
    278         }
     291       
    279292        fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
    280293        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
    281         if(! device){
     294        if (!device) {
    282295                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    283296                return ENOENT;
     
    285298        *content = device->mtu;
    286299        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
     300       
    287301        *addr_len = 0;
    288302        *prefix = 0;
     
    291305}
    292306
    293 int nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet, services_t target){
     307int
     308nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet,
     309    services_t target)
     310{
    294311        packet_t next;
    295312
    296313        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    297         if(nildummy_globals.proto.phone){
    298                 do{
     314        if (nildummy_globals.proto.phone) {
     315                do {
    299316                        next = pq_detach(packet);
    300                         il_received_msg(nildummy_globals.proto.phone, device_id, packet, nildummy_globals.proto.service);
     317                        il_received_msg(nildummy_globals.proto.phone, device_id,
     318                            packet, nildummy_globals.proto.service);
    301319                        packet = next;
    302                 }while(packet);
     320                } while(packet);
    303321        }
    304322        fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
     323       
    305324        return EOK;
    306325}
     
    310329 * Pass received packets for this service.
    311330 *
    312  * @param[in] service The module service.
    313  * @param[in] phone   The service phone.
    314  *
    315  * @return EOK on success.
    316  * @return ENOENT if the service is not known.
    317  * @return ENOMEM if there is not enough memory left.
    318  *
     331 * @param[in] service   The module service.
     332 * @param[in] phone     The service phone.
     333 * @return              EOK on success.
     334 * @return              ENOENT if the service is not known.
     335 * @return              ENOMEM if there is not enough memory left.
    319336 */
    320337static int nildummy_register_message(services_t service, int phone)
     
    333350/** Send the packet queue.
    334351 *
    335  * @param[in] device_id The device identifier.
    336  * @param[in] packet    The packet queue.
    337  * @param[in] sender    The sending module service.
    338  *
    339  * @return EOK on success.
    340  * @return ENOENT if there no such device.
    341  * @return EINVAL if the service parameter is not known.
    342  *
    343  */
    344 static int nildummy_send_message(device_id_t device_id, packet_t packet,
    345     services_t sender)
     352 * @param[in] device_id The device identifier.
     353 * @param[in] packet    The packet queue.
     354 * @param[in] sender    The sending module service.
     355 * @return              EOK on success.
     356 * @return              ENOENT if there no such device.
     357 * @return              EINVAL if the service parameter is not known.
     358 */
     359static int
     360nildummy_send_message(device_id_t device_id, packet_t packet, services_t sender)
    346361{
    347362        nildummy_device_ref device;
     
    349364        fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
    350365        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
    351         if(! device){
     366        if (!device) {
    352367                fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    353368                return ENOENT;
    354369        }
    355370        // send packet queue
    356         if(packet){
    357                 netif_send_msg(device->phone, device_id, packet, SERVICE_NILDUMMY);
    358         }
     371        if (packet)
     372                netif_send_msg(device->phone, device_id, packet,
     373                    SERVICE_NILDUMMY);
    359374        fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
    360375        return EOK;
    361376}
    362377
    363 int nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
     378int
     379nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
    364380    ipc_call_t *answer, int *answer_count)
    365381{
     
    375391        *answer_count = 0;
    376392        switch (IPC_GET_METHOD(*call)) {
    377                 case IPC_M_PHONE_HUNGUP:
    378                         return EOK;
    379                 case NET_NIL_DEVICE:
    380                         return nildummy_device_message(IPC_GET_DEVICE(call),
    381                             IPC_GET_SERVICE(call), IPC_GET_MTU(call));
    382                 case NET_NIL_SEND:
    383                         ERROR_PROPAGATE(packet_translate_remote(nildummy_globals.net_phone,
    384                             &packet, IPC_GET_PACKET(call)));
    385                         return nildummy_send_message(IPC_GET_DEVICE(call), packet,
    386                             IPC_GET_SERVICE(call));
    387                 case NET_NIL_PACKET_SPACE:
    388                         ERROR_PROPAGATE(nildummy_packet_space_message(IPC_GET_DEVICE(call),
    389                             &addrlen, &prefix, &content, &suffix));
    390                         IPC_SET_ADDR(answer, addrlen);
    391                         IPC_SET_PREFIX(answer, prefix);
    392                         IPC_SET_CONTENT(answer, content);
    393                         IPC_SET_SUFFIX(answer, suffix);
    394                         *answer_count = 4;
    395                         return EOK;
    396                 case NET_NIL_ADDR:
    397                         ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
    398                             &address));
    399                         return measured_strings_reply(address, 1);
    400                 case NET_NIL_BROADCAST_ADDR:
    401                         ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
    402                             &address));
    403                         return measured_strings_reply(address, 1);
    404                 case IPC_M_CONNECT_TO_ME:
    405                         return nildummy_register_message(NIL_GET_PROTO(call),
    406                             IPC_GET_PHONE(call));
     393        case IPC_M_PHONE_HUNGUP:
     394                return EOK;
     395       
     396        case NET_NIL_DEVICE:
     397                return nildummy_device_message(IPC_GET_DEVICE(call),
     398                    IPC_GET_SERVICE(call), IPC_GET_MTU(call));
     399       
     400        case NET_NIL_SEND:
     401                ERROR_PROPAGATE(packet_translate_remote(
     402                    nildummy_globals.net_phone, &packet, IPC_GET_PACKET(call)));
     403                return nildummy_send_message(IPC_GET_DEVICE(call), packet,
     404                    IPC_GET_SERVICE(call));
     405       
     406        case NET_NIL_PACKET_SPACE:
     407                ERROR_PROPAGATE(nildummy_packet_space_message(
     408                    IPC_GET_DEVICE(call), &addrlen, &prefix, &content,
     409                    &suffix));
     410                IPC_SET_ADDR(answer, addrlen);
     411                IPC_SET_PREFIX(answer, prefix);
     412                IPC_SET_CONTENT(answer, content);
     413                IPC_SET_SUFFIX(answer, suffix);
     414                *answer_count = 4;
     415                return EOK;
     416       
     417        case NET_NIL_ADDR:
     418                ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
     419                    &address));
     420                return measured_strings_reply(address, 1);
     421       
     422        case NET_NIL_BROADCAST_ADDR:
     423                ERROR_PROPAGATE(nildummy_addr_message(IPC_GET_DEVICE(call),
     424                    &address));
     425                return measured_strings_reply(address, 1);
     426       
     427        case IPC_M_CONNECT_TO_ME:
     428                return nildummy_register_message(NIL_GET_PROTO(call),
     429                    IPC_GET_PHONE(call));
    407430        }
    408431       
     
    412435/** Default thread for new connections.
    413436 *
    414  * @param[in] iid   The initial message identifier.
    415  * @param[in] icall The initial message call structure.
    416  *
     437 * @param[in] iid       The initial message identifier.
     438 * @param[in] icall     The initial message call structure.
    417439 */
    418440static void nil_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     
    424446        ipc_answer_0(iid, EOK);
    425447       
    426         while(true) {
     448        while (true) {
    427449                ipc_call_t answer;
    428450                int answer_count;
     
    436458               
    437459                /* Process the message */
    438                 int res = nil_module_message_standalone(NAME, callid, &call, &answer,
    439                     &answer_count);
    440                
    441                 /* End if said to either by the message or the processing result */
    442                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
     460                int res = nil_module_message_standalone(NAME, callid, &call,
     461                    &answer, &answer_count);
     462               
     463                /*
     464                 * End if told to either by the message or the processing
     465                 * result.
     466                 */
     467                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     468                    (res == EHANGUP))
    443469                        return;
    444470               
     
    453479       
    454480        /* Start the module */
    455         if (ERROR_OCCURRED(nil_module_start_standalone(nil_client_connection)))
    456                 return ERROR_CODE;
    457        
     481        ERROR_PROPAGATE(nil_module_start_standalone(nil_client_connection));
    458482        return EOK;
    459483}
Note: See TracChangeset for help on using the changeset viewer.