Changeset 973ef9fc in mainline for uspace/srv/net


Ignore:
Timestamp:
2010-12-25T21:20:28Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
631ee0c
Parents:
1bfd3d3 (diff), 09178b7f (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 mainline changes.

Location:
uspace/srv/net
Files:
2 deleted
22 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/cfg/Makefile

    r1bfd3d3 r973ef9fc  
    3636-include $(CONFIG_MAKEFILE)
    3737
    38 ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
    39         LO_SOURCE = lo.netif_nil_bundle
    40         NE2K_SOURCE = ne2k.netif_nil_bundle
    41 else
    42         LO_SOURCE = lo.netif_standalone
    43         NE2K_SOURCE = ne2k.netif_standalone
    44 endif
     38LO_SOURCE = lo.netif_standalone
     39NE2K_SOURCE = ne2k.netif_standalone
    4540
    4641LO_TARGET = lo

  • uspace/srv/net/il/arp/arp.c

    r1bfd3d3 r973ef9fc  
    7272#define NAME  "arp"
    7373
     74/** Number of microseconds to wait for an ARP reply. */
     75#define ARP_TRANS_WAIT  1000000
     76
    7477/** ARP global data. */
    7578arp_globals_t arp_globals;
    … …  
    7780DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t);
    7881INT_MAP_IMPLEMENT(arp_protos, arp_proto_t);
    79 GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, measured_string_t);
     82GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, arp_trans_t);
     83
     84static void arp_clear_trans(arp_trans_t *trans)
     85{
     86        if (trans->hw_addr) {
     87                free(trans->hw_addr);
     88                trans->hw_addr = NULL;
     89        }
     90        fibril_condvar_broadcast(&trans->cv);
     91}
     92
     93static void arp_clear_addr(arp_addr_t *addresses)
     94{
     95        int count;
     96        arp_trans_t *trans;
     97
     98        for (count = arp_addr_count(addresses) - 1; count >= 0; count--) {
     99                trans = arp_addr_items_get_index(&addresses->values, count);
     100                if (trans)
     101                        arp_clear_trans(trans);
     102        }
     103}
     104
    80105
    81106/** Clears the device specific data.
    … …  
    96121                        if (proto->addr_data)
    97122                                free(proto->addr_data);
     123                        arp_clear_addr(&proto->addresses);
    98124                        arp_addr_destroy(&proto->addresses);
    99125                }
    … …  
    107133        arp_device_t *device;
    108134
    109         fibril_rwlock_write_lock(&arp_globals.lock);
     135        fibril_mutex_lock(&arp_globals.lock);
    110136        for (count = arp_cache_count(&arp_globals.cache) - 1; count >= 0;
    111137            count--) {
    … …  
    120146        }
    121147        arp_cache_clear(&arp_globals.cache);
    122         fibril_rwlock_write_unlock(&arp_globals.lock);
     148        fibril_mutex_unlock(&arp_globals.lock);
    123149        printf("Cache cleaned\n");
    124150        return EOK;
    … …  
    130156        arp_device_t *device;
    131157        arp_proto_t *proto;
    132 
    133         fibril_rwlock_write_lock(&arp_globals.lock);
     158        arp_trans_t *trans;
     159
     160        fibril_mutex_lock(&arp_globals.lock);
    134161        device = arp_cache_find(&arp_globals.cache, device_id);
    135162        if (!device) {
    136                 fibril_rwlock_write_unlock(&arp_globals.lock);
     163                fibril_mutex_unlock(&arp_globals.lock);
    137164                return ENOENT;
    138165        }
    139166        proto = arp_protos_find(&device->protos, protocol);
    140167        if (!proto) {
    141                 fibril_rwlock_write_unlock(&arp_globals.lock);
     168                fibril_mutex_unlock(&arp_globals.lock);
    142169                return ENOENT;
    143170        }
     171        trans = arp_addr_find(&proto->addresses, address->value, address->length);
     172        if (trans)
     173                arp_clear_trans(trans);
    144174        arp_addr_exclude(&proto->addresses, address->value, address->length);
    145         fibril_rwlock_write_unlock(&arp_globals.lock);
     175        fibril_mutex_unlock(&arp_globals.lock);
    146176        return EOK;
    147177}
    … …  
    152182        arp_device_t *device;
    153183
    154         fibril_rwlock_write_lock(&arp_globals.lock);
     184        fibril_mutex_lock(&arp_globals.lock);
    155185        device = arp_cache_find(&arp_globals.cache, device_id);
    156186        if (!device) {
    157                 fibril_rwlock_write_unlock(&arp_globals.lock);
     187                fibril_mutex_unlock(&arp_globals.lock);
    158188                return ENOENT;
    159189        }
    160190        arp_clear_device(device);
    161191        printf("Device %d cleared\n", device_id);
    162         fibril_rwlock_write_unlock(&arp_globals.lock);
     192        fibril_mutex_unlock(&arp_globals.lock);
    163193        return EOK;
    164194}
    … …  
    221251        int rc;
    222252
    223         fibril_rwlock_write_lock(&arp_globals.lock);
     253        fibril_mutex_lock(&arp_globals.lock);
    224254
    225255        /* An existing device? */
    … …  
    229259                if (device->service != service) {
    230260                        printf("Device %d already exists\n", device->device_id);
    231                         fibril_rwlock_write_unlock(&arp_globals.lock);
     261                        fibril_mutex_unlock(&arp_globals.lock);
    232262                        return EEXIST;
    233263                }
    … …  
    241271                        rc = arp_proto_create(&proto, protocol, address);
    242272                        if (rc != EOK) {
    243                                 fibril_rwlock_write_unlock(&arp_globals.lock);
     273                                fibril_mutex_unlock(&arp_globals.lock);
    244274                                return rc;
    245275                        }
    … …  
    247277                            proto);
    248278                        if (index < 0) {
    249                                 fibril_rwlock_write_unlock(&arp_globals.lock);
     279                                fibril_mutex_unlock(&arp_globals.lock);
    250280                                free(proto);
    251281                                return index;
    … …  
    262292                device = (arp_device_t *) malloc(sizeof(arp_device_t));
    263293                if (!device) {
    264                         fibril_rwlock_write_unlock(&arp_globals.lock);
     294                        fibril_mutex_unlock(&arp_globals.lock);
    265295                        return ENOMEM;
    266296                }
    … …  
    269299                rc = arp_protos_initialize(&device->protos);
    270300                if (rc != EOK) {
    271                         fibril_rwlock_write_unlock(&arp_globals.lock);
     301                        fibril_mutex_unlock(&arp_globals.lock);
    272302                        free(device);
    273303                        return rc;
    … …  
    275305                rc = arp_proto_create(&proto, protocol, address);
    276306                if (rc != EOK) {
    277                         fibril_rwlock_write_unlock(&arp_globals.lock);
     307                        fibril_mutex_unlock(&arp_globals.lock);
    278308                        free(device);
    279309                        return rc;
    … …  
    281311                index = arp_protos_add(&device->protos, proto->service, proto);
    282312                if (index < 0) {
    283                         fibril_rwlock_write_unlock(&arp_globals.lock);
     313                        fibril_mutex_unlock(&arp_globals.lock);
    284314                        arp_protos_destroy(&device->protos);
    285315                        free(device);
    … …  
    290320                /* Bind the new one */
    291321                device->phone = nil_bind_service(device->service,
    292                     (ipcarg_t) device->device_id, SERVICE_ARP,
     322                    (sysarg_t) device->device_id, SERVICE_ARP,
    293323                    arp_globals.client_connection);
    294324                if (device->phone < 0) {
    295                         fibril_rwlock_write_unlock(&arp_globals.lock);
     325                        fibril_mutex_unlock(&arp_globals.lock);
    296326                        arp_protos_destroy(&device->protos);
    297327                        free(device);
    … …  
    303333                    &device->packet_dimension);
    304334                if (rc != EOK) {
    305                         fibril_rwlock_write_unlock(&arp_globals.lock);
     335                        fibril_mutex_unlock(&arp_globals.lock);
    306336                        arp_protos_destroy(&device->protos);
    307337                        free(device);
    … …  
    313343                    &device->addr_data);
    314344                if (rc != EOK) {
    315                         fibril_rwlock_write_unlock(&arp_globals.lock);
     345                        fibril_mutex_unlock(&arp_globals.lock);
    316346                        arp_protos_destroy(&device->protos);
    317347                        free(device);
    … …  
    323353                    &device->broadcast_addr, &device->broadcast_data);
    324354                if (rc != EOK) {
    325                         fibril_rwlock_write_unlock(&arp_globals.lock);
     355                        fibril_mutex_unlock(&arp_globals.lock);
    326356                        free(device->addr);
    327357                        free(device->addr_data);
    … …  
    334364                    device);
    335365                if (rc != EOK) {
    336                         fibril_rwlock_write_unlock(&arp_globals.lock);
     366                        fibril_mutex_unlock(&arp_globals.lock);
    337367                        free(device->addr);
    338368                        free(device->addr_data);
    … …  
    347377                    device->service, protocol);
    348378        }
    349         fibril_rwlock_write_unlock(&arp_globals.lock);
     379        fibril_mutex_unlock(&arp_globals.lock);
    350380       
    351381        return EOK;
    … …  
    363393        int rc;
    364394
    365         fibril_rwlock_initialize(&arp_globals.lock);
    366         fibril_rwlock_write_lock(&arp_globals.lock);
     395        fibril_mutex_initialize(&arp_globals.lock);
     396        fibril_mutex_lock(&arp_globals.lock);
    367397        arp_globals.client_connection = client_connection;
    368398        rc = arp_cache_initialize(&arp_globals.cache);
    369         fibril_rwlock_write_unlock(&arp_globals.lock);
     399        fibril_mutex_unlock(&arp_globals.lock);
    370400       
    371401        return rc;
    … …  
    383413        arp_device_t *device;
    384414
    385         fibril_rwlock_write_lock(&arp_globals.lock);
     415        fibril_mutex_lock(&arp_globals.lock);
    386416        device = arp_cache_find(&arp_globals.cache, device_id);
    387417        if (!device) {
    388                 fibril_rwlock_write_unlock(&arp_globals.lock);
     418                fibril_mutex_unlock(&arp_globals.lock);
    389419                return ENOENT;
    390420        }
    391421        device->packet_dimension.content = mtu;
    392         fibril_rwlock_write_unlock(&arp_globals.lock);
    393         printf("arp - device %d changed mtu to %d\n\n", device_id, mtu);
     422        fibril_mutex_unlock(&arp_globals.lock);
     423        printf("arp - device %d changed mtu to %zu\n\n", device_id, mtu);
    394424        return EOK;
    395425}
    … …  
    415445 * @return              ENOMEM if there is not enough memory left.
    416446 */
    417 static int arp_receive_message(device_id_t device_id, packet_t packet)
     447static int arp_receive_message(device_id_t device_id, packet_t *packet)
    418448{
    419449        size_t length;
    … …  
    421451        arp_device_t *device;
    422452        arp_proto_t *proto;
    423         measured_string_t *hw_source;
     453        arp_trans_t *trans;
    424454        uint8_t *src_hw;
    425455        uint8_t *src_proto;
    … …  
    452482        des_hw = src_proto + header->protocol_length;
    453483        des_proto = des_hw + header->hardware_length;
    454         hw_source = arp_addr_find(&proto->addresses, (char *) src_proto,
    455             CONVERT_SIZE(uint8_t, char, header->protocol_length));
     484        trans = arp_addr_find(&proto->addresses, (char *) src_proto,
     485            header->protocol_length);
    456486        /* Exists? */
    457         if (hw_source) {
    458                 if (hw_source->length != CONVERT_SIZE(uint8_t, char,
    459                     header->hardware_length)) {
     487        if (trans && trans->hw_addr) {
     488                if (trans->hw_addr->length != header->hardware_length)
    460489                        return EINVAL;
    461                 }
    462                 memcpy(hw_source->value, src_hw, hw_source->length);
     490                memcpy(trans->hw_addr->value, src_hw, trans->hw_addr->length);
    463491        }
    464492        /* Is my protocol address? */
    465         if (proto->addr->length != CONVERT_SIZE(uint8_t, char,
    466             header->protocol_length)) {
     493        if (proto->addr->length != header->protocol_length)
    467494                return EINVAL;
    468         }
    469495        if (!str_lcmp(proto->addr->value, (char *) des_proto,
    470496            proto->addr->length)) {
    471497                /* Not already updated? */
    472                 if (!hw_source) {
    473                         hw_source = measured_string_create_bulk((char *) src_hw,
    474                             CONVERT_SIZE(uint8_t, char,
    475                             header->hardware_length));
    476                         if (!hw_source)
     498                if (!trans) {
     499                        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
     500                        if (!trans)
    477501                                return ENOMEM;
    478 
     502                        trans->hw_addr = NULL;
     503                        fibril_condvar_initialize(&trans->cv);
    479504                        rc = arp_addr_add(&proto->addresses, (char *) src_proto,
    480                             CONVERT_SIZE(uint8_t, char,
    481                             header->protocol_length), hw_source);
    482                         if (rc != EOK)
     505                            header->protocol_length, trans);
     506                        if (rc != EOK) {
     507                                /* The generic char map has already freed trans! */
    483508                                return rc;
     509                        }
     510                }
     511                if (!trans->hw_addr) {
     512                        trans->hw_addr = measured_string_create_bulk(
     513                            (char *) src_hw, header->hardware_length);
     514                        if (!trans->hw_addr)
     515                                return ENOMEM;
     516
     517                        /* Notify the fibrils that wait for the translation. */
     518                        fibril_condvar_broadcast(&trans->cv);
    484519                }
    485520                if (ntohs(header->operation) == ARPOP_REQUEST) {
    … …  
    490525                        memcpy(src_hw, device->addr->value,
    491526                            device->packet_dimension.addr_len);
    492                         memcpy(des_hw, hw_source->value,
     527                        memcpy(des_hw, trans->hw_addr->value,
    493528                            header->hardware_length);
    494529                       
    … …  
    516551 * @param[in] protocol  The protocol service.
    517552 * @param[in] target    The target protocol address.
    518  * @return              The hardware address of the target.
    519  * @return              NULL if the target parameter is NULL.
    520  * @return              NULL if the device is not found.
    521  * @return              NULL if the device packet is too small to send a
    522  *                      request.
    523  * @return              NULL if the hardware address is not found in the cache.
    524  */
    525 static measured_string_t *
     553 * @param[out] translation Where the hardware address of the target is stored.
     554 * @return              EOK on success.
     555 * @return              EAGAIN if the caller should try again.
     556 * @return              Other error codes in case of error.
     557 */
     558static int
    526559arp_translate_message(device_id_t device_id, services_t protocol,
    527     measured_string_t *target)
     560    measured_string_t *target, measured_string_t **translation)
    528561{
    529562        arp_device_t *device;
    530563        arp_proto_t *proto;
    531         measured_string_t *addr;
     564        arp_trans_t *trans;
    532565        size_t length;
    533         packet_t packet;
     566        packet_t *packet;
    534567        arp_header_t *header;
    535 
    536         if (!target)
    537                 return NULL;
     568        bool retry = false;
     569        int rc;
     570
     571restart:
     572        if (!target || !translation)
     573                return EBADMEM;
    538574
    539575        device = arp_cache_find(&arp_globals.cache, device_id);
    540576        if (!device)
    541                 return NULL;
     577                return ENOENT;
    542578
    543579        proto = arp_protos_find(&device->protos, protocol);
    544580        if (!proto || (proto->addr->length != target->length))
    545                 return NULL;
    546 
    547         addr = arp_addr_find(&proto->addresses, target->value, target->length);
    548         if (addr)
    549                 return addr;
     581                return ENOENT;
     582
     583        trans = arp_addr_find(&proto->addresses, target->value, target->length);
     584        if (trans) {
     585                if (trans->hw_addr) {
     586                        *translation = trans->hw_addr;
     587                        return EOK;
     588                }
     589                if (retry)
     590                        return EAGAIN;
     591                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
     592                    ARP_TRANS_WAIT);
     593                if (rc == ETIMEOUT)
     594                        return ENOENT;
     595                retry = true;
     596                goto restart;
     597        }
     598        if (retry)
     599                return EAGAIN;
    550600
    551601        /* ARP packet content size = header + (address + translation) * 2 */
    552         length = 8 + 2 * (CONVERT_SIZE(char, uint8_t, proto->addr->length) +
    553             CONVERT_SIZE(char, uint8_t, device->addr->length));
     602        length = 8 + 2 * (proto->addr->length + device->addr->length);
    554603        if (length > device->packet_dimension.content)
    555                 return NULL;
     604                return ELIMIT;
    556605
    557606        packet = packet_get_4_remote(arp_globals.net_phone,
    … …  
    559608            length, device->packet_dimension.suffix);
    560609        if (!packet)
    561                 return NULL;
     610                return ENOMEM;
    562611
    563612        header = (arp_header_t *) packet_suffix(packet, length);
    564613        if (!header) {
    565614                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
    566                 return NULL;
     615                return ENOMEM;
    567616        }
    568617
    … …  
    583632        memcpy(((uint8_t *) header) + length, target->value, target->length);
    584633
    585         if (packet_set_addr(packet, (uint8_t *) device->addr->value,
    586             (uint8_t *) device->broadcast_addr->value,
    587             CONVERT_SIZE(char, uint8_t, device->addr->length)) != EOK) {
     634        rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
     635            (uint8_t *) device->broadcast_addr->value, device->addr->length);
     636        if (rc != EOK) {
    588637                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
    589                 return NULL;
     638                return rc;
    590639        }
    591640
    592641        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
    593         return NULL;
     642
     643        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
     644        if (!trans)
     645                return ENOMEM;
     646        trans->hw_addr = NULL;
     647        fibril_condvar_initialize(&trans->cv);
     648        rc = arp_addr_add(&proto->addresses, target->value, target->length,
     649            trans);
     650        if (rc != EOK) {
     651                /* The generic char map has already freed trans! */
     652                return rc;
     653        }
     654       
     655        rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
     656            ARP_TRANS_WAIT);
     657        if (rc == ETIMEOUT)
     658                return ENOENT;
     659        retry = true;
     660        goto restart;
    594661}
    595662
    … …  
    615682        measured_string_t *translation;
    616683        char *data;
    617         packet_t packet;
    618         packet_t next;
     684        packet_t *packet;
     685        packet_t *next;
    619686        int rc;
    620687       
    621688        *answer_count = 0;
    622         switch (IPC_GET_METHOD(*call)) {
     689        switch (IPC_GET_IMETHOD(*call)) {
    623690        case IPC_M_PHONE_HUNGUP:
    624691                return EOK;
    … …  
    642709                        return rc;
    643710               
    644                 fibril_rwlock_read_lock(&arp_globals.lock);
    645                 translation = arp_translate_message(IPC_GET_DEVICE(call),
    646                     IPC_GET_SERVICE(call), address);
     711                fibril_mutex_lock(&arp_globals.lock);
     712                rc = arp_translate_message(IPC_GET_DEVICE(call),
     713                    IPC_GET_SERVICE(call), address, &translation);
    647714                free(address);
    648715                free(data);
     716                if (rc != EOK) {
     717                        fibril_mutex_unlock(&arp_globals.lock);
     718                        return rc;
     719                }
    649720                if (!translation) {
    650                         fibril_rwlock_read_unlock(&arp_globals.lock);
     721                        fibril_mutex_unlock(&arp_globals.lock);
    651722                        return ENOENT;
    652723                }
    653724                rc = measured_strings_reply(translation, 1);
    654                 fibril_rwlock_read_unlock(&arp_globals.lock);
     725                fibril_mutex_unlock(&arp_globals.lock);
    655726                return rc;
    656727
    … …  
    682753                        return rc;
    683754               
    684                 fibril_rwlock_read_lock(&arp_globals.lock);
     755                fibril_mutex_lock(&arp_globals.lock);
    685756                do {
    686757                        next = pq_detach(packet);
    … …  
    692763                        packet = next;
    693764                } while (packet);
    694                 fibril_rwlock_read_unlock(&arp_globals.lock);
     765                fibril_mutex_unlock(&arp_globals.lock);
    695766               
    696767                return EOK;
    … …  
    736807                 * result.
    737808                 */
    738                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     809                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    739810                    (res == EHANGUP))
    740811                        return;

  • uspace/srv/net/il/arp/arp.h

    r1bfd3d3 r973ef9fc  
    6565typedef struct arp_proto arp_proto_t;
    6666
     67/** Type definition of the ARP address translation record.
     68 * @see arp_trans
     69 */
     70typedef struct arp_trans arp_trans_t;
     71
    6772/** ARP address map.
    6873 *
    … …  
    7075 * @see generic_char_map.h
    7176 */
    72 GENERIC_CHAR_MAP_DECLARE(arp_addr, measured_string_t);
     77GENERIC_CHAR_MAP_DECLARE(arp_addr, arp_trans_t);
    7378
    7479/** ARP address cache.
    … …  
    8994struct arp_device {
    9095        /** Actual device hardware address. */
    91         measured_string_t * addr;
     96        measured_string_t *addr;
    9297        /** Actual device hardware address data. */
    9398        char *addr_data;
    9499        /** Broadcast device hardware address. */
    95         measured_string_t * broadcast_addr;
     100        measured_string_t *broadcast_addr;
    96101        /** Broadcast device hardware address data. */
    97102        char *broadcast_data;
    … …  
    129134        int net_phone;
    130135        /** Safety lock. */
    131         fibril_rwlock_t lock;
     136        fibril_mutex_t lock;
    132137};
    133138
    … …  
    144149};
    145150
     151/** ARP address translation record. */
     152struct arp_trans {
     153        /**
     154         * Hardware address for the translation. NULL denotes an incomplete
     155         * record with possible waiters.
     156         */
     157        measured_string_t *hw_addr;
     158        /** Condition variable used for waiting for completion of the record. */
     159        fibril_condvar_t cv;
     160};
     161
    146162#endif
    147163
    148164/** @}
    149165 */
     166

  • uspace/srv/net/il/arp/arp_module.c

    r1bfd3d3 r973ef9fc  
    6565int il_module_start_standalone(async_client_conn_t client_connection)
    6666{
    67         ipcarg_t phonehash;
     67        sysarg_t phonehash;
    6868        int rc;
    6969       
    … …  
    7979                goto out;
    8080       
    81         rc = REGISTER_ME(SERVICE_ARP, &phonehash);
     81        rc = ipc_connect_to_me(PHONE_NS, SERVICE_ARP, 0, 0, &phonehash);
    8282        if (rc != EOK)
    8383                goto out;

  • uspace/srv/net/il/ip/ip.c

    r1bfd3d3 r973ef9fc  
    129129 * @return              The result parameter.
    130130 */
    131 static int ip_release_and_return(packet_t packet, int result)
     131static int ip_release_and_return(packet_t *packet, int result)
    132132{
    133133        pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
    … …  
    170170 * @return              Other error codes as defined for the packet_set_addr().
    171171 */
    172 static int ip_prepare_icmp(packet_t packet, ip_header_t *header)
    173 {
    174         packet_t next;
     172static int ip_prepare_icmp(packet_t *packet, ip_header_t *header)
     173{
     174        packet_t *next;
    175175        struct sockaddr *dest;
    176176        struct sockaddr_in dest_in;
    … …  
    233233 */
    234234static int
    235 ip_prepare_icmp_and_get_phone(services_t error, packet_t packet,
     235ip_prepare_icmp_and_get_phone(services_t error, packet_t *packet,
    236236    ip_header_t *header)
    237237{
    … …  
    430430        // binds the netif service which also initializes the device
    431431        ip_netif->phone = nil_bind_service(ip_netif->service,
    432             (ipcarg_t) ip_netif->device_id, SERVICE_IP,
     432            (sysarg_t) ip_netif->device_id, SERVICE_IP,
    433433            ip_globals.client_connection);
    434434        if (ip_netif->phone < 0) {
    … …  
    442442                if (route) {
    443443                        address.value = (char *) &route->address.s_addr;
    444                         address.length = CONVERT_SIZE(in_addr_t, char, 1);
     444                        address.length = sizeof(in_addr_t);
    445445                       
    446446                        rc = arp_device_req(ip_netif->arp->phone,
    … …  
    461461       
    462462        if (ip_netif->packet_dimension.content < IP_MIN_CONTENT) {
    463                 printf("Maximum transmission unit %d bytes is too small, at "
     463                printf("Maximum transmission unit %zu bytes is too small, at "
    464464                    "least %d bytes are needed\n",
    465465                    ip_netif->packet_dimension.content, IP_MIN_CONTENT);
    … …  
    502502        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
    503503
    504         printf("%s: Device %d changed MTU to %d\n", NAME, device_id, mtu);
     504        printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
    505505
    506506        return EOK;
    … …  
    543543 */
    544544static ip_header_t *
    545 ip_create_middle_header(packet_t packet, ip_header_t *last)
     545ip_create_middle_header(packet_t *packet, ip_header_t *last)
    546546{
    547547        ip_header_t *middle;
    … …  
    622622 */
    623623static int
    624 ip_prepare_packet(in_addr_t *source, in_addr_t dest, packet_t packet,
     624ip_prepare_packet(in_addr_t *source, in_addr_t dest, packet_t *packet,
    625625    measured_string_t *destination)
    626626{
    … …  
    629629        ip_header_t *last_header;
    630630        ip_header_t *middle_header;
    631         packet_t next;
     631        packet_t *next;
    632632        int rc;
    633633
    … …  
    639639        if (destination) {
    640640                rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
    641                     CONVERT_SIZE(char, uint8_t, destination->length));
     641                    destination->length);
    642642        } else {
    643643                rc = packet_set_addr(packet, NULL, NULL, 0);
    … …  
    687687                                rc = packet_set_addr(next, NULL,
    688688                                    (uint8_t *) destination->value,
    689                                     CONVERT_SIZE(char, uint8_t,
    690                                     destination->length));
     689                                    destination->length);
    691690                                if (rc != EOK) {
    692691                                        free(last_header);
    … …  
    718717                        rc = packet_set_addr(next, NULL,
    719718                            (uint8_t *) destination->value,
    720                             CONVERT_SIZE(char, uint8_t, destination->length));
     719                            destination->length);
    721720                        if (rc != EOK) {
    722721                                free(last_header);
    … …  
    754753 */
    755754static int
    756 ip_fragment_packet_data(packet_t packet, packet_t new_packet,
     755ip_fragment_packet_data(packet_t *packet, packet_t *new_packet,
    757756    ip_header_t *header, ip_header_t *new_header, size_t length,
    758757    const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen)
    … …  
    816815 */
    817816static int
    818 ip_fragment_packet(packet_t packet, size_t length, size_t prefix, size_t suffix,
     817ip_fragment_packet(packet_t *packet, size_t length, size_t prefix, size_t suffix,
    819818    socklen_t addr_len)
    820819{
    821         packet_t new_packet;
     820        packet_t *new_packet;
    822821        ip_header_t *header;
    823822        ip_header_t *middle_header;
    … …  
    922921 * @return              NULL if there are no packets left.
    923922 */
    924 static packet_t
    925 ip_split_packet(packet_t packet, size_t prefix, size_t content, size_t suffix,
     923static packet_t *
     924ip_split_packet(packet_t *packet, size_t prefix, size_t content, size_t suffix,
    926925    socklen_t addr_len, services_t error)
    927926{
    928927        size_t length;
    929         packet_t next;
    930         packet_t new_packet;
     928        packet_t *next;
     929        packet_t *new_packet;
    931930        int result;
    932931        int phone;
    … …  
    993992 */
    994993static int
    995 ip_send_route(packet_t packet, ip_netif_t *netif, ip_route_t *route,
     994ip_send_route(packet_t *packet, ip_netif_t *netif, ip_route_t *route,
    996995    in_addr_t *src, in_addr_t dest, services_t error)
    997996{
    … …  
    10061005                destination.value = route->gateway.s_addr ?
    10071006                    (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
    1008                 destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
     1007                destination.length = sizeof(dest.s_addr);
    10091008
    10101009                rc = arp_translate_req(netif->arp->phone, netif->device_id,
    … …  
    12471246
    12481247static int
    1249 ip_send_msg_local(int il_phone, device_id_t device_id, packet_t packet,
     1248ip_send_msg_local(int il_phone, device_id_t device_id, packet_t *packet,
    12501249    services_t sender, services_t error)
    12511250{
    … …  
    14511450 */
    14521451static int
    1453 ip_deliver_local(device_id_t device_id, packet_t packet, ip_header_t *header,
     1452ip_deliver_local(device_id_t device_id, packet_t *packet, ip_header_t *header,
    14541453    services_t error)
    14551454{
    … …  
    15531552 */
    15541553static int
    1555 ip_process_packet(device_id_t device_id, packet_t packet)
     1554ip_process_packet(device_id_t device_id, packet_t *packet)
    15561555{
    15571556        ip_header_t *header;
    … …  
    17151714static int
    17161715ip_received_error_msg_local(int ip_phone, device_id_t device_id,
    1717     packet_t packet, services_t target, services_t error)
     1716    packet_t *packet, services_t target, services_t error)
    17181717{
    17191718        uint8_t *data;
    … …  
    17581757                        // clear the ARP mapping if any
    17591758                        address.value = (char *) &header->destination_address;
    1760                         address.length = CONVERT_SIZE(uint8_t, char,
    1761                             sizeof(header->destination_address));
     1759                        address.length = sizeof(header->destination_address);
    17621760                        arp_clear_address_req(netif->arp->phone,
    17631761                            netif->device_id, SERVICE_IP, &address);
    … …  
    18591857 * @return              ENOMEM if there is not enough memory left.
    18601858 */
    1861 static int ip_receive_message(device_id_t device_id, packet_t packet)
    1862 {
    1863         packet_t next;
     1859static int ip_receive_message(device_id_t device_id, packet_t *packet)
     1860{
     1861        packet_t *next;
    18641862
    18651863        do {
    … …  
    18901888    int *answer_count)
    18911889{
    1892         packet_t packet;
     1890        packet_t *packet;
    18931891        struct sockaddr *addr;
    18941892        size_t addrlen;
    … …  
    19021900       
    19031901        *answer_count = 0;
    1904         switch (IPC_GET_METHOD(*call)) {
     1902        switch (IPC_GET_IMETHOD(*call)) {
    19051903        case IPC_M_PHONE_HUNGUP:
    19061904                return EOK;
    … …  
    19511949
    19521950        case NET_IP_GET_ROUTE:
    1953                 rc = data_receive((void **) &addr, &addrlen);
     1951                rc = async_data_write_accept((void **) &addr, false, 0, 0, 0,
     1952                    &addrlen);
    19541953                if (rc != EOK)
    19551954                        return rc;
    … …  
    20252024                 * result.
    20262025                 */
    2027                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     2026                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    20282027                    (res == EHANGUP)) {
    20292028                        return;

  • uspace/srv/net/il/ip/ip_module.c

    r1bfd3d3 r973ef9fc  
    6666int il_module_start_standalone(async_client_conn_t client_connection)
    6767{
    68         ipcarg_t phonehash;
     68        sysarg_t phonehash;
    6969        int rc;
    7070       
    … …  
    8080                goto out;
    8181       
    82         rc = REGISTER_ME(SERVICE_IP, &phonehash);
     82        rc = ipc_connect_to_me(PHONE_NS, SERVICE_IP, 0, 0, &phonehash);
    8383        if (rc != EOK)
    8484                goto out;

  • uspace/srv/net/net/net.c

    r1bfd3d3 r973ef9fc  
    322322static int net_module_start(async_client_conn_t client_connection)
    323323{
    324         ipcarg_t phonehash;
     324        sysarg_t phonehash;
    325325        int rc;
    326326       
    … …  
    335335                goto out;
    336336       
    337         rc = REGISTER_ME(SERVICE_NETWORKING, &phonehash);
     337        rc = ipc_connect_to_me(PHONE_NS, SERVICE_NETWORKING, 0, 0, &phonehash);
    338338        if (rc != EOK)
    339339                goto out;
    … …  
    632632       
    633633        *answer_count = 0;
    634         switch (IPC_GET_METHOD(*call)) {
     634        switch (IPC_GET_IMETHOD(*call)) {
    635635        case IPC_M_PHONE_HUNGUP:
    636636                return EOK;
    … …  
    697697               
    698698                /* End if told to either by the message or the processing result */
    699                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
     699                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
    700700                        return;
    701701               

  • uspace/srv/net/netif/lo/Makefile

    r1bfd3d3 r973ef9fc  
    3939-include $(CONFIG_MAKEFILE)
    4040
    41 ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
    42         LIBS += $(USPACE_PREFIX)/srv/net/nil/nildummy/libnildummy.a
    43 endif
    44 
    4541BINARY = lo
    4642

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

    r1bfd3d3 r973ef9fc  
    164164int netif_initialize(void)
    165165{
    166         ipcarg_t phonehash;
    167 
    168         return REGISTER_ME(SERVICE_LO, &phonehash);
     166        sysarg_t phonehash;
     167
     168        return ipc_connect_to_me(PHONE_NS, SERVICE_LO, 0, 0, &phonehash);
    169169}
    170170
    … …  
    185185}
    186186
    187 int netif_send_message(device_id_t device_id, packet_t packet, services_t sender)
     187int netif_send_message(device_id_t device_id, packet_t *packet, services_t sender)
    188188{
    189189        netif_device_t *device;
    190190        size_t length;
    191         packet_t next;
     191        packet_t *next;
    192192        int phone;
    193193        int rc;
    … …  
    262262                 * result.
    263263                 */
    264                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     264                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    265265                    (res == EHANGUP))
    266266                        return;

  • uspace/srv/net/nil/eth/Makefile

    r1bfd3d3 r973ef9fc  
    3939-include $(CONFIG_MAKEFILE)
    4040
    41 ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
    42         LIBRARY = libeth
    43 else
    44         BINARY = eth
    45 endif
     41BINARY = eth
    4642
    4743SOURCES = \

  • uspace/srv/net/nil/eth/eth.c

    r1bfd3d3 r973ef9fc  
    201201
    202202        eth_globals.broadcast_addr =
    203             measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF",
    204             CONVERT_SIZE(uint8_t, char, ETH_ADDR));
     203            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
    205204        if (!eth_globals.broadcast_addr) {
    206205                rc = ENOMEM;
    … …  
    234233static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall)
    235234{
    236         packet_t packet;
     235        packet_t *packet;
    237236        int rc;
    238237
    239238        while (true) {
    240                 switch (IPC_GET_METHOD(*icall)) {
     239                switch (IPC_GET_IMETHOD(*icall)) {
    241240                case NET_NIL_DEVICE_STATE:
    242241                        nil_device_state_msg_local(0, IPC_GET_DEVICE(icall),
    … …  
    251250                                    IPC_GET_DEVICE(icall), packet, 0);
    252251                        }
    253                         ipc_answer_0(iid, (ipcarg_t) rc);
     252                        ipc_answer_0(iid, (sysarg_t) rc);
    254253                        break;
    255254                default:
    256                         ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
     255                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
    257256                }
    258257               
    … …  
    315314                        device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
    316315               
    317                 printf("Device %d already exists:\tMTU\t= %d\n",
     316                printf("Device %d already exists:\tMTU\t= %zu\n",
    318317                    device->device_id, device->mtu);
    319318                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    … …  
    407406        }
    408407       
    409         printf("%s: Device registered (id: %d, service: %d: mtu: %d, "
     408        printf("%s: Device registered (id: %d, service: %d: mtu: %zu, "
    410409            "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
    411410            NAME, device->device_id, device->service, device->mtu,
    … …  
    429428 * @return              NULL if the packet address length is not big enough.
    430429 */
    431 static eth_proto_t *eth_process_packet(int flags, packet_t packet)
     430static eth_proto_t *eth_process_packet(int flags, packet_t *packet)
    432431{
    433432        eth_header_snap_t *header;
    … …  
    509508
    510509int nil_received_msg_local(int nil_phone, device_id_t device_id,
    511     packet_t packet, services_t target)
     510    packet_t *packet, services_t target)
    512511{
    513512        eth_proto_t *proto;
    514         packet_t next;
     513        packet_t *next;
    515514        eth_device_t *device;
    516515        int flags;
    … …  
    680679 */
    681680static int
    682 eth_prepare_packet(int flags, packet_t packet, uint8_t *src_addr, int ethertype,
     681eth_prepare_packet(int flags, packet_t *packet, uint8_t *src_addr, int ethertype,
    683682    size_t mtu)
    684683{
    … …  
    787786 * @return              EINVAL if the service parameter is not known.
    788787 */
    789 static int eth_send_message(device_id_t device_id, packet_t packet,
     788static int eth_send_message(device_id_t device_id, packet_t *packet,
    790789    services_t sender)
    791790{
    792791        eth_device_t *device;
    793         packet_t next;
    794         packet_t tmp;
     792        packet_t *next;
     793        packet_t *tmp;
    795794        int ethertype;
    796795        int rc;
    … …  
    841840{
    842841        measured_string_t *address;
    843         packet_t packet;
     842        packet_t *packet;
    844843        size_t addrlen;
    845844        size_t prefix;
    … …  
    849848       
    850849        *answer_count = 0;
    851         switch (IPC_GET_METHOD(*call)) {
     850        switch (IPC_GET_IMETHOD(*call)) {
    852851        case IPC_M_PHONE_HUNGUP:
    853852                return EOK;
    … …  
    926925                 * result.
    927926                 */
    928                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     927                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    929928                    (res == EHANGUP))
    930929                        return;

  • uspace/srv/net/nil/eth/eth_module.c

    r1bfd3d3 r973ef9fc  
    5252int nil_module_start_standalone(async_client_conn_t client_connection)
    5353{
    54         ipcarg_t phonehash;
     54        sysarg_t phonehash;
    5555        int rc;
    5656       
    … …  
    6666                goto out;
    6767
    68         rc = REGISTER_ME(SERVICE_ETHERNET, &phonehash);
     68        rc = ipc_connect_to_me(PHONE_NS, SERVICE_ETHERNET, 0, 0, &phonehash);
    6969        if (rc != EOK)
    7070                goto out;

  • uspace/srv/net/nil/nildummy/Makefile

    r1bfd3d3 r973ef9fc  
    3939-include $(CONFIG_MAKEFILE)
    4040
    41 ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
    42         LIBRARY = libnildummy
    43 else
    44         BINARY = nildummy
    45 endif
     41BINARY = nildummy
    4642
    4743SOURCES = \

  • uspace/srv/net/nil/nildummy/nildummy.c

    r1bfd3d3 r973ef9fc  
    106106static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall)
    107107{
    108         packet_t packet;
     108        packet_t *packet;
    109109        int rc;
    110110
    111111        while (true) {
    112                 switch (IPC_GET_METHOD(*icall)) {
     112                switch (IPC_GET_IMETHOD(*icall)) {
    113113                case NET_NIL_DEVICE_STATE:
    114114                        rc = nil_device_state_msg_local(0,
    115115                            IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
    116                         ipc_answer_0(iid, (ipcarg_t) rc);
     116                        ipc_answer_0(iid, (sysarg_t) rc);
    117117                        break;
    118118               
    … …  
    124124                                    IPC_GET_DEVICE(icall), packet, 0);
    125125                        }
    126                         ipc_answer_0(iid, (ipcarg_t) rc);
     126                        ipc_answer_0(iid, (sysarg_t) rc);
    127127                        break;
    128128               
    129129                default:
    130                         ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
     130                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
    131131                }
    132132               
    … …  
    175175                        device->mtu = NET_DEFAULT_MTU;
    176176               
    177                 printf("Device %d already exists:\tMTU\t= %d\n",
     177                printf("Device %d already exists:\tMTU\t= %zu\n",
    178178                    device->device_id, device->mtu);
    179179                fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    232232        }
    233233       
    234         printf("%s: Device registered (id: %d, service: %d, mtu: %d)\n",
     234        printf("%s: Device registered (id: %d, service: %d, mtu: %zu)\n",
    235235            NAME, device->device_id, device->service, device->mtu);
    236236        fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
    … …  
    304304
    305305int nil_received_msg_local(int nil_phone, device_id_t device_id,
    306     packet_t packet, services_t target)
    307 {
    308         packet_t next;
     306    packet_t *packet, services_t target)
     307{
     308        packet_t *next;
    309309
    310310        fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
    … …  
    354354 * @return              EINVAL if the service parameter is not known.
    355355 */
    356 static int nildummy_send_message(device_id_t device_id, packet_t packet,
     356static int nildummy_send_message(device_id_t device_id, packet_t *packet,
    357357    services_t sender)
    358358{
    … …  
    378378{
    379379        measured_string_t *address;
    380         packet_t packet;
     380        packet_t *packet;
    381381        size_t addrlen;
    382382        size_t prefix;
    … …  
    386386       
    387387        *answer_count = 0;
    388         switch (IPC_GET_METHOD(*call)) {
     388        switch (IPC_GET_IMETHOD(*call)) {
    389389        case IPC_M_PHONE_HUNGUP:
    390390                return EOK;
    … …  
    466466                 * result.
    467467                 */
    468                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     468                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    469469                    (res == EHANGUP))
    470470                        return;

  • uspace/srv/net/nil/nildummy/nildummy_module.c

    r1bfd3d3 r973ef9fc  
    5252int nil_module_start_standalone(async_client_conn_t client_connection)
    5353{
    54         ipcarg_t phonehash;
     54        sysarg_t phonehash;
    5555        int rc;
    5656       
    … …  
    6767                goto out;
    6868       
    69         rc = REGISTER_ME(SERVICE_NILDUMMY, &phonehash);
     69        rc = ipc_connect_to_me(PHONE_NS, SERVICE_NILDUMMY, 0, 0, &phonehash);
    7070        if (rc != EOK)
    7171                goto out;

  • uspace/srv/net/tl/icmp/icmp.c

    r1bfd3d3 r973ef9fc  
    130130 * @return              The result parameter.
    131131 */
    132 static int icmp_release_and_return(packet_t packet, int result)
     132static int icmp_release_and_return(packet_t *packet, int result)
    133133{
    134134        pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
    … …  
    155155 * @return              EPERM if the error message is not allowed.
    156156 */
    157 static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet,
     157static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t *packet,
    158158    icmp_header_t *header, services_t error, ip_ttl_t ttl, ip_tos_t tos,
    159159    int dont_fragment)
    … …  
    189189 * @return NULL on errors.
    190190 */
    191 static icmp_header_t *icmp_prepare_packet(packet_t packet)
     191static icmp_header_t *icmp_prepare_packet(packet_t *packet)
    192192{
    193193        icmp_header_t *header;
    … …  
    248248{
    249249        icmp_header_t *header;
    250         packet_t packet;
     250        packet_t *packet;
    251251        size_t length;
    252252        uint8_t *data;
    … …  
    340340
    341341static int icmp_destination_unreachable_msg_local(int icmp_phone,
    342     icmp_code_t code, icmp_param_t mtu, packet_t packet)
     342    icmp_code_t code, icmp_param_t mtu, packet_t *packet)
    343343{
    344344        icmp_header_t *header;
    … …  
    355355}
    356356
    357 static int icmp_source_quench_msg_local(int icmp_phone, packet_t packet)
     357static int icmp_source_quench_msg_local(int icmp_phone, packet_t *packet)
    358358{
    359359        icmp_header_t *header;
    … …  
    368368
    369369static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code,
    370     packet_t packet)
     370    packet_t *packet)
    371371{
    372372        icmp_header_t *header;
    … …  
    381381
    382382static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
    383     icmp_param_t pointer, packet_t packet)
     383    icmp_param_t pointer, packet_t *packet)
    384384{
    385385        icmp_header_t *header;
    … …  
    479479 * @param[in] code      The received reply message code.
    480480 */
    481 static void  icmp_process_echo_reply(packet_t packet, icmp_header_t *header,
     481static void  icmp_process_echo_reply(packet_t *packet, icmp_header_t *header,
    482482    icmp_type_t type, icmp_code_t code)
    483483{
    … …  
    518518 *                      ip_client_process_packet() function.
    519519 */
    520 static int icmp_process_packet(packet_t packet, services_t error)
     520static int icmp_process_packet(packet_t *packet, services_t error)
    521521{
    522522        size_t length;
    … …  
    658658 *                      icmp_process_packet() function.
    659659 */
    660 static int icmp_received_msg_local(device_id_t device_id, packet_t packet,
     660static int icmp_received_msg_local(device_id_t device_id, packet_t *packet,
    661661    services_t receiver, services_t error)
    662662{
    … …  
    690690static int icmp_process_message(ipc_call_t *call)
    691691{
    692         packet_t packet;
     692        packet_t *packet;
    693693        int rc;
    694694
    695         switch (IPC_GET_METHOD(*call)) {
     695        switch (IPC_GET_IMETHOD(*call)) {
    696696        case NET_ICMP_DEST_UNREACH:
    697697                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    … …  
    824824
    825825                /* Process the call */
    826                 switch (IPC_GET_METHOD(call)) {
     826                switch (IPC_GET_IMETHOD(call)) {
    827827                case IPC_M_PHONE_HUNGUP:
    828828                        keep_on_going = false;
    … …  
    896896    ipc_call_t *answer, int *answer_count)
    897897{
    898         packet_t packet;
     898        packet_t *packet;
    899899        int rc;
    900900
    901901        *answer_count = 0;
    902         switch (IPC_GET_METHOD(*call)) {
     902        switch (IPC_GET_IMETHOD(*call)) {
    903903        case NET_TL_RECEIVED:
    904904                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
    … …  
    953953                 * result.
    954954                 */
    955                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     955                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    956956                    (res == EHANGUP))
    957957                        return;

  • uspace/srv/net/tl/icmp/icmp_module.c

    r1bfd3d3 r973ef9fc  
    5858int tl_module_start_standalone(async_client_conn_t client_connection)
    5959{
    60         ipcarg_t phonehash;
     60        sysarg_t phonehash;
    6161        int rc;
    6262
    … …  
    7474                goto out;
    7575
    76         rc = REGISTER_ME(SERVICE_ICMP, &phonehash);
     76        rc = ipc_connect_to_me(PHONE_NS, SERVICE_ICMP, 0, 0, &phonehash);
    7777        if (rc != EOK)
    7878                goto out;

  • uspace/srv/net/tl/tcp/tcp.c

    r1bfd3d3 r973ef9fc  
    160160};
    161161
    162 static int tcp_release_and_return(packet_t, int);
     162static int tcp_release_and_return(packet_t *, int);
    163163static void tcp_prepare_operation_header(socket_core_t *, tcp_socket_data_t *,
    164164    tcp_header_t *, int synchronize, int);
    … …  
    171171static int tcp_release_after_timeout(void *);
    172172
    173 static int tcp_process_packet(device_id_t, packet_t, services_t);
     173static int tcp_process_packet(device_id_t, packet_t *, services_t);
    174174static int tcp_connect_core(socket_core_t *, socket_cores_t *,
    175175    struct sockaddr *, socklen_t);
    176176static int tcp_queue_prepare_packet(socket_core_t *, tcp_socket_data_t *,
    177     packet_t, size_t);
    178 static int tcp_queue_packet(socket_core_t *, tcp_socket_data_t *, packet_t,
     177    packet_t *, size_t);
     178static int tcp_queue_packet(socket_core_t *, tcp_socket_data_t *, packet_t *,
    179179    size_t);
    180 static packet_t tcp_get_packets_to_send(socket_core_t *, tcp_socket_data_t *);
    181 static void tcp_send_packets(device_id_t, packet_t);
     180static packet_t *tcp_get_packets_to_send(socket_core_t *, tcp_socket_data_t *);
     181static void tcp_send_packets(device_id_t, packet_t *);
    182182
    183183static void tcp_process_acknowledgement(socket_core_t *, tcp_socket_data_t *,
    184184    tcp_header_t *);
    185 static packet_t tcp_send_prepare_packet(socket_core_t *, tcp_socket_data_t *,
    186     packet_t, size_t, size_t);
    187 static packet_t tcp_prepare_copy(socket_core_t *, tcp_socket_data_t *, packet_t,
    188     size_t, size_t);
     185static packet_t *tcp_send_prepare_packet(socket_core_t *, tcp_socket_data_t *,
     186    packet_t *, size_t, size_t);
     187static packet_t *tcp_prepare_copy(socket_core_t *, tcp_socket_data_t *,
     188    packet_t *, size_t, size_t);
    189189/* static */ void tcp_retransmit_packet(socket_core_t *, tcp_socket_data_t *,
    190190    size_t);
    191 static int tcp_create_notification_packet(packet_t *, socket_core_t *,
     191static int tcp_create_notification_packet(packet_t **, socket_core_t *,
    192192    tcp_socket_data_t *, int, int);
    193193static void tcp_refresh_socket_data(tcp_socket_data_t *);
    … …  
    196196
    197197static int tcp_process_listen(socket_core_t *, tcp_socket_data_t *,
    198     tcp_header_t *, packet_t, struct sockaddr *, struct sockaddr *, size_t);
     198    tcp_header_t *, packet_t *, struct sockaddr *, struct sockaddr *, size_t);
    199199static int tcp_process_syn_sent(socket_core_t *, tcp_socket_data_t *,
    200     tcp_header_t *, packet_t);
     200    tcp_header_t *, packet_t *);
    201201static int tcp_process_syn_received(socket_core_t *, tcp_socket_data_t *,
    202     tcp_header_t *, packet_t);
     202    tcp_header_t *, packet_t *);
    203203static int tcp_process_established(socket_core_t *, tcp_socket_data_t *,
    204     tcp_header_t *, packet_t, int, size_t);
     204    tcp_header_t *, packet_t *, int, size_t);
    205205static int tcp_queue_received_packet(socket_core_t *, tcp_socket_data_t *,
    206     packet_t, int, size_t);
    207 
    208 static int tcp_received_msg(device_id_t, packet_t, services_t, services_t);
     206    packet_t *, int, size_t);
     207
     208static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
    209209static int tcp_process_client_messages(ipc_callid_t, ipc_call_t);
    210210
    … …  
    262262}
    263263
    264 int tcp_received_msg(device_id_t device_id, packet_t packet,
     264int tcp_received_msg(device_id_t device_id, packet_t *packet,
    265265    services_t receiver, services_t error)
    266266{
    … …  
    280280}
    281281
    282 int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error)
     282int tcp_process_packet(device_id_t device_id, packet_t *packet, services_t error)
    283283{
    284284        size_t length;
    … …  
    288288        socket_core_t *socket;
    289289        tcp_socket_data_t *socket_data;
    290         packet_t next_packet;
     290        packet_t *next_packet;
    291291        size_t total_length;
    292292        uint32_t checksum;
    … …  
    453453
    454454has_error_service:
    455         fibril_rwlock_read_unlock(&tcp_globals.lock);
     455        fibril_rwlock_write_unlock(&tcp_globals.lock);
    456456
    457457        /* TODO error reporting/handling */
    … …  
    493493
    494494int tcp_process_established(socket_core_t *socket, tcp_socket_data_t *
    495     socket_data, tcp_header_t *header, packet_t packet, int fragments,
     495    socket_data, tcp_header_t *header, packet_t *packet, int fragments,
    496496    size_t total_length)
    497497{
    498         packet_t next_packet;
    499         packet_t tmp_packet;
     498        packet_t *next_packet;
     499        packet_t *tmp_packet;
    500500        uint32_t old_incoming;
    501501        size_t order;
    … …  
    801801
    802802int tcp_queue_received_packet(socket_core_t *socket,
    803     tcp_socket_data_t *socket_data, packet_t packet, int fragments,
     803    tcp_socket_data_t *socket_data, packet_t *packet, int fragments,
    804804    size_t total_length)
    805805{
    … …  
    829829        /* Notify the destination socket */
    830830        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    831             (ipcarg_t) socket->socket_id,
     831            (sysarg_t) socket->socket_id,
    832832            ((packet_dimension->content < socket_data->data_fragment_size) ?
    833833            packet_dimension->content : socket_data->data_fragment_size), 0, 0,
    834             (ipcarg_t) fragments);
     834            (sysarg_t) fragments);
    835835
    836836        return EOK;
    … …  
    838838
    839839int tcp_process_syn_sent(socket_core_t *socket, tcp_socket_data_t *
    840     socket_data, tcp_header_t *header, packet_t packet)
    841 {
    842         packet_t next_packet;
     840    socket_data, tcp_header_t *header, packet_t *packet)
     841{
     842        packet_t *next_packet;
    843843        int rc;
    844844
    … …  
    897897int tcp_process_listen(socket_core_t *listening_socket,
    898898    tcp_socket_data_t *listening_socket_data, tcp_header_t *header,
    899     packet_t packet, struct sockaddr *src, struct sockaddr *dest,
     899    packet_t *packet, struct sockaddr *src, struct sockaddr *dest,
    900900    size_t addrlen)
    901901{
    902         packet_t next_packet;
     902        packet_t *next_packet;
    903903        socket_core_t *socket;
    904904        tcp_socket_data_t *socket_data;
    … …  
    10561056
    10571057int tcp_process_syn_received(socket_core_t *socket,
    1058     tcp_socket_data_t *socket_data, tcp_header_t *header, packet_t packet)
     1058    tcp_socket_data_t *socket_data, tcp_header_t *header, packet_t *packet)
    10591059{
    10601060        socket_core_t *listening_socket;
    … …  
    10901090                        /* Notify the destination socket */
    10911091                        async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
    1092                             (ipcarg_t) listening_socket->socket_id,
     1092                            (sysarg_t) listening_socket->socket_id,
    10931093                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
    1094                             0, (ipcarg_t) socket->socket_id);
     1094                            0, (sysarg_t) socket->socket_id);
    10951095
    10961096                        fibril_rwlock_write_unlock(socket_data->local_lock);
    … …  
    11271127        size_t number;
    11281128        size_t length;
    1129         packet_t packet;
    1130         packet_t next;
    1131         packet_t acknowledged = NULL;
     1129        packet_t *packet;
     1130        packet_t *next;
     1131        packet_t *acknowledged = NULL;
    11321132        uint32_t old;
    11331133
    … …  
    12321232    ipc_call_t *answer, int *answer_count)
    12331233{
    1234         packet_t packet;
     1234        packet_t *packet;
    12351235        int rc;
    12361236
    … …  
    12401240
    12411241        *answer_count = 0;
    1242         switch (IPC_GET_METHOD(*call)) {
     1242        switch (IPC_GET_IMETHOD(*call)) {
    12431243        case NET_TL_RECEIVED:
    12441244//              fibril_rwlock_read_lock(&tcp_globals.lock);
    … …  
    13231323
    13241324                /* Process the call */
    1325                 switch (IPC_GET_METHOD(call)) {
     1325                switch (IPC_GET_IMETHOD(call)) {
    13261326                case IPC_M_PHONE_HUNGUP:
    13271327                        keep_on_going = false;
    … …  
    13651365
    13661366                case NET_SOCKET_BIND:
    1367                         res = data_receive((void **) &addr, &addrlen);
     1367                        res = async_data_write_accept((void **) &addr, false,
     1368                            0, 0, 0, &addrlen);
    13681369                        if (res != EOK)
    13691370                                break;
    … …  
    14021403
    14031404                case NET_SOCKET_CONNECT:
    1404                         res = data_receive((void **) &addr, &addrlen);
     1405                        res = async_data_write_accept((void **) &addr, false,
     1406                            0, 0, 0, &addrlen);
    14051407                        if (res != EOK)
    14061408                                break;
    … …  
    14531455
    14541456                case NET_SOCKET_SENDTO:
    1455                         res = data_receive((void **) &addr, &addrlen);
     1457                        res = async_data_write_accept((void **) &addr, false,
     1458                            0, 0, 0, &addrlen);
    14561459                        if (res != EOK)
    14571460                                break;
    … …  
    16541657    socket_data, size_t sequence_number)
    16551658{
    1656         packet_t packet;
    1657         packet_t copy;
     1659        packet_t *packet;
     1660        packet_t *copy;
    16581661        size_t data_length;
    16591662
    … …  
    17361739{
    17371740        tcp_socket_data_t *socket_data;
    1738         packet_t packet;
     1741        packet_t *packet;
    17391742        int rc;
    17401743
    … …  
    18001803                        fibril_rwlock_write_unlock(socket_data->local_lock);
    18011804
     1805                        socket_data->state = TCP_SOCKET_SYN_SENT;
     1806
    18021807                        /* Send the packet */
    18031808                        printf("connecting %d\n", packet_get_id(packet));
    … …  
    18241829
    18251830int tcp_queue_prepare_packet(socket_core_t *socket,
    1826     tcp_socket_data_t *socket_data, packet_t packet, size_t data_length)
     1831    tcp_socket_data_t *socket_data, packet_t *packet, size_t data_length)
    18271832{
    18281833        tcp_header_t *header;
    … …  
    18551860
    18561861int tcp_queue_packet(socket_core_t *socket, tcp_socket_data_t *socket_data,
    1857     packet_t packet, size_t data_length)
     1862    packet_t *packet, size_t data_length)
    18581863{
    18591864        int rc;
    … …  
    18761881}
    18771882
    1878 packet_t tcp_get_packets_to_send(socket_core_t *socket, tcp_socket_data_t *
     1883packet_t *tcp_get_packets_to_send(socket_core_t *socket, tcp_socket_data_t *
    18791884    socket_data)
    18801885{
    1881         packet_t packet;
    1882         packet_t copy;
    1883         packet_t sending = NULL;
    1884         packet_t previous = NULL;
     1886        packet_t *packet;
     1887        packet_t *copy;
     1888        packet_t *sending = NULL;
     1889        packet_t *previous = NULL;
    18851890        size_t data_length;
    18861891        int rc;
    … …  
    19361941}
    19371942
    1938 packet_t tcp_send_prepare_packet(socket_core_t *socket, tcp_socket_data_t *
    1939     socket_data, packet_t packet, size_t data_length, size_t sequence_number)
     1943packet_t *tcp_send_prepare_packet(socket_core_t *socket, tcp_socket_data_t *
     1944    socket_data, packet_t *packet, size_t data_length, size_t sequence_number)
    19401945{
    19411946        tcp_header_t *header;
    … …  
    19972002}
    19982003
    1999 packet_t tcp_prepare_copy(socket_core_t *socket, tcp_socket_data_t *
    2000     socket_data, packet_t packet, size_t data_length, size_t sequence_number)
    2001 {
    2002         packet_t copy;
     2004packet_t *tcp_prepare_copy(socket_core_t *socket, tcp_socket_data_t *
     2005    socket_data, packet_t *packet, size_t data_length, size_t sequence_number)
     2006{
     2007        packet_t *copy;
    20032008
    20042009        assert(socket);
    … …  
    20152020}
    20162021
    2017 void tcp_send_packets(device_id_t device_id, packet_t packet)
    2018 {
    2019         packet_t next;
     2022void tcp_send_packets(device_id_t device_id, packet_t *packet)
     2023{
     2024        packet_t *next;
    20202025
    20212026        while (packet) {
    … …  
    20822087        if (!fibril) {
    20832088                free(operation_timeout);
    2084                 return EPARTY;  /* FIXME: use another EC */
    2085         }
     2089                return ENOMEM;
     2090        }
     2091
    20862092//      fibril_mutex_lock(&socket_data->operation.mutex);
    20872093        /* Start the timeout fibril */
    … …  
    20972103        tcp_socket_data_t *socket_data;
    20982104        int packet_id;
    2099         packet_t packet;
     2105        packet_t *packet;
    21002106        size_t length;
    21012107        int rc;
    … …  
    21552161        tcp_socket_data_t *socket_data;
    21562162        packet_dimension_t *packet_dimension;
    2157         packet_t packet;
     2163        packet_t *packet;
    21582164        size_t total_length;
    21592165        tcp_header_t *header;
    … …  
    22292235        socket_core_t *socket;
    22302236        tcp_socket_data_t *socket_data;
    2231         packet_t packet;
     2237        packet_t *packet;
    22322238        int rc;
    22332239
    … …  
    22932299}
    22942300
    2295 int tcp_create_notification_packet(packet_t *packet, socket_core_t *socket,
     2301int tcp_create_notification_packet(packet_t **packet, socket_core_t *socket,
    22962302    tcp_socket_data_t *socket_data, int synchronize, int finalize)
    22972303{
    … …  
    24422448 * @return              The result parameter.
    24432449 */
    2444 int tcp_release_and_return(packet_t packet, int result)
     2450int tcp_release_and_return(packet_t *packet, int result)
    24452451{
    24462452        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    … …  
    24812487                 * result.
    24822488                 */
    2483                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     2489                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    24842490                    (res == EHANGUP))
    24852491                        return;

  • uspace/srv/net/tl/tcp/tcp.h

    r1bfd3d3 r973ef9fc  
    239239         * Packets metric is set as their data length.
    240240         */
    241         packet_t incoming;
     241        packet_t *incoming;
    242242       
    243243        /** Outgoing packet queue.
    … …  
    249249         * Packets metric is set as their data length.
    250250         */
    251         packet_t outgoing;
     251        packet_t *outgoing;
    252252       
    253253        /** IP pseudo header. */

  • uspace/srv/net/tl/tcp/tcp_module.c

    r1bfd3d3 r973ef9fc  
    6161int tl_module_start_standalone(async_client_conn_t client_connection)
    6262{
    63         ipcarg_t phonehash;
     63        sysarg_t phonehash;
    6464        int rc;
    6565
    … …  
    7575                goto out;
    7676
    77         rc = REGISTER_ME(SERVICE_TCP, &phonehash);
     77        rc = ipc_connect_to_me(PHONE_NS, SERVICE_TCP, 0, 0, &phonehash);
    7878        if (rc != EOK)
    7979                goto out;

  • uspace/srv/net/tl/udp/udp.c

    r1bfd3d3 r973ef9fc  
    190190 * @return              The result parameter.
    191191 */
    192 static int udp_release_and_return(packet_t packet, int result)
     192static int udp_release_and_return(packet_t *packet, int result)
    193193{
    194194        pq_release_remote(udp_globals.net_phone, packet_get_id(packet));
    … …  
    217217 *                      ip_client_process_packet() function.
    218218 */
    219 static int udp_process_packet(device_id_t device_id, packet_t packet,
     219static int udp_process_packet(device_id_t device_id, packet_t *packet,
    220220    services_t error)
    221221{
    … …  
    225225        udp_header_t *header;
    226226        socket_core_t *socket;
    227         packet_t next_packet;
     227        packet_t *next_packet;
    228228        size_t total_length;
    229229        uint32_t checksum;
    230230        int fragments;
    231         packet_t tmp_packet;
     231        packet_t *tmp_packet;
    232232        icmp_type_t type;
    233233        icmp_code_t code;
    … …  
    393393        fibril_rwlock_write_unlock(&udp_globals.lock);
    394394        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
    395             (ipcarg_t) socket->socket_id, packet_dimension->content, 0, 0,
    396             (ipcarg_t) fragments);
     395            (sysarg_t) socket->socket_id, packet_dimension->content, 0, 0,
     396            (sysarg_t) fragments);
    397397
    398398        return EOK;
    … …  
    413413 *                      udp_process_packet() function.
    414414 */
    415 static int udp_received_msg(device_id_t device_id, packet_t packet,
     415static int udp_received_msg(device_id_t device_id, packet_t *packet,
    416416    services_t receiver, services_t error)
    417417{
    … …  
    458458{
    459459        socket_core_t *socket;
    460         packet_t packet;
    461         packet_t next_packet;
     460        packet_t *packet;
     461        packet_t *next_packet;
    462462        udp_header_t *header;
    463463        int index;
    … …  
    614614        socket_core_t *socket;
    615615        int packet_id;
    616         packet_t packet;
     616        packet_t *packet;
    617617        udp_header_t *header;
    618618        struct sockaddr *addr;
    … …  
    742742
    743743                /* Process the call */
    744                 switch (IPC_GET_METHOD(call)) {
     744                switch (IPC_GET_IMETHOD(call)) {
    745745                case IPC_M_PHONE_HUNGUP:
    746746                        keep_on_going = false;
    … …  
    771771
    772772                case NET_SOCKET_BIND:
    773                         res = data_receive((void **) &addr, &addrlen);
     773                        res = async_data_write_accept((void **) &addr, false,
     774                            0, 0, 0, &addrlen);
    774775                        if (res != EOK)
    775776                                break;
    … …  
    784785
    785786                case NET_SOCKET_SENDTO:
    786                         res = data_receive((void **) &addr, &addrlen);
     787                        res = async_data_write_accept((void **) &addr, false,
     788                            0, 0, 0, &addrlen);
    787789                        if (res != EOK)
    788790                                break;
    … …  
    861863    ipc_call_t *answer, int *answer_count)
    862864{
    863         packet_t packet;
     865        packet_t *packet;
    864866        int rc;
    865867
    866868        *answer_count = 0;
    867869
    868         switch (IPC_GET_METHOD(*call)) {
     870        switch (IPC_GET_IMETHOD(*call)) {
    869871        case NET_TL_RECEIVED:
    870872                rc = packet_translate_remote(udp_globals.net_phone, &packet,
    … …  
    913915                 * result.
    914916                 */
    915                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     917                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
    916918                    (res == EHANGUP))
    917919                        return;

  • uspace/srv/net/tl/udp/udp_module.c

    r1bfd3d3 r973ef9fc  
    5959int tl_module_start_standalone(async_client_conn_t client_connection)
    6060{
    61         ipcarg_t phonehash;
     61        sysarg_t phonehash;
    6262        int rc;
    6363
    … …  
    7575                goto out;
    7676       
    77         rc = REGISTER_ME(SERVICE_UDP, &phonehash);
     77        rc = ipc_connect_to_me(PHONE_NS, SERVICE_UDP, 0, 0, &phonehash);
    7878        if (rc != EOK)
    7979                goto out;
Note: See TracChangeset for help on using the changeset viewer.