Changeset 984a9ba in mainline for uspace/lib/drv/generic/remote_nic.c


Ignore:
Timestamp:
2018-07-05T09:34:09Z (7 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
63d46341
Parents:
76f566d
Message:

do not expose the call capability handler from the async framework

Keep the call capability handler encapsulated within the async framework
and do not expose it explicitly via its API. Use the pointer to
ipc_call_t as the sole object identifying an IPC call in the code that
uses the async framework.

This plugs a major leak in the abstraction and also simplifies both the
async framework (slightly) and all IPC servers.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/drv/generic/remote_nic.c

    r76f566d r984a9ba  
    13371337
    13381338static void remote_nic_send_frame(ddf_fun_t *dev, void *iface,
    1339     cap_call_handle_t chandle, ipc_call_t *call)
     1339    ipc_call_t *call)
    13401340{
    13411341        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13481348        rc = async_data_write_accept(&data, false, 0, 0, 0, &size);
    13491349        if (rc != EOK) {
    1350                 async_answer_0(chandle, EINVAL);
     1350                async_answer_0(call, EINVAL);
    13511351                return;
    13521352        }
    13531353
    13541354        rc = nic_iface->send_frame(dev, data, size);
    1355         async_answer_0(chandle, rc);
     1355        async_answer_0(call, rc);
    13561356        free(data);
    13571357}
    13581358
    13591359static void remote_nic_callback_create(ddf_fun_t *dev, void *iface,
    1360     cap_call_handle_t chandle, ipc_call_t *call)
     1360    ipc_call_t *call)
    13611361{
    13621362        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13641364
    13651365        errno_t rc = nic_iface->callback_create(dev);
    1366         async_answer_0(chandle, rc);
     1366        async_answer_0(call, rc);
    13671367}
    13681368
    13691369static void remote_nic_get_state(ddf_fun_t *dev, void *iface,
    1370     cap_call_handle_t chandle, ipc_call_t *call)
     1370    ipc_call_t *call)
    13711371{
    13721372        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13761376
    13771377        errno_t rc = nic_iface->get_state(dev, &state);
    1378         async_answer_1(chandle, rc, state);
     1378        async_answer_1(call, rc, state);
    13791379}
    13801380
    13811381static void remote_nic_set_state(ddf_fun_t *dev, void *iface,
    1382     cap_call_handle_t chandle, ipc_call_t *call)
     1382    ipc_call_t *call)
    13831383{
    13841384        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    13881388
    13891389        errno_t rc = nic_iface->set_state(dev, state);
    1390         async_answer_0(chandle, rc);
     1390        async_answer_0(call, rc);
    13911391}
    13921392
    13931393static void remote_nic_get_address(ddf_fun_t *dev, void *iface,
    1394     cap_call_handle_t chandle, ipc_call_t *call)
     1394    ipc_call_t *call)
    13951395{
    13961396        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    14021402        errno_t rc = nic_iface->get_address(dev, &address);
    14031403        if (rc == EOK) {
     1404                ipc_call_t data;
    14041405                size_t max_len;
    1405                 cap_call_handle_t data_chandle;
    14061406
    14071407                /* All errors will be translated into EPARTY anyway */
    1408                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    1409                         async_answer_0(data_chandle, EINVAL);
    1410                         async_answer_0(chandle, EINVAL);
     1408                if (!async_data_read_receive(&data, &max_len)) {
     1409                        async_answer_0(&data, EINVAL);
     1410                        async_answer_0(call, EINVAL);
    14111411                        return;
    14121412                }
    14131413
    14141414                if (max_len != sizeof(nic_address_t)) {
    1415                         async_answer_0(data_chandle, ELIMIT);
    1416                         async_answer_0(chandle, ELIMIT);
    1417                         return;
    1418                 }
    1419 
    1420                 async_data_read_finalize(data_chandle, &address,
     1415                        async_answer_0(&data, ELIMIT);
     1416                        async_answer_0(call, ELIMIT);
     1417                        return;
     1418                }
     1419
     1420                async_data_read_finalize(&data, &address,
    14211421                    sizeof(nic_address_t));
    14221422        }
    14231423
    1424         async_answer_0(chandle, rc);
     1424        async_answer_0(call, rc);
    14251425}
    14261426
    14271427static void remote_nic_set_address(ddf_fun_t *dev, void *iface,
    1428     cap_call_handle_t chandle, ipc_call_t *call)
    1429 {
    1430         nic_iface_t *nic_iface = (nic_iface_t *) iface;
    1431 
     1428    ipc_call_t *call)
     1429{
     1430        nic_iface_t *nic_iface = (nic_iface_t *) iface;
     1431
     1432        ipc_call_t data;
    14321433        size_t length;
    1433         cap_call_handle_t data_chandle;
    1434         if (!async_data_write_receive(&data_chandle, &length)) {
    1435                 async_answer_0(data_chandle, EINVAL);
    1436                 async_answer_0(chandle, EINVAL);
     1434        if (!async_data_write_receive(&data, &length)) {
     1435                async_answer_0(&data, EINVAL);
     1436                async_answer_0(call, EINVAL);
    14371437                return;
    14381438        }
    14391439
    14401440        if (length > sizeof(nic_address_t)) {
    1441                 async_answer_0(data_chandle, ELIMIT);
    1442                 async_answer_0(chandle, ELIMIT);
     1441                async_answer_0(&data, ELIMIT);
     1442                async_answer_0(call, ELIMIT);
    14431443                return;
    14441444        }
    14451445
    14461446        nic_address_t address;
    1447         if (async_data_write_finalize(data_chandle, &address, length) != EOK) {
    1448                 async_answer_0(chandle, EINVAL);
     1447        if (async_data_write_finalize(&data, &address, length) != EOK) {
     1448                async_answer_0(call, EINVAL);
    14491449                return;
    14501450        }
    … …  
    14521452        if (nic_iface->set_address != NULL) {
    14531453                errno_t rc = nic_iface->set_address(dev, &address);
    1454                 async_answer_0(chandle, rc);
     1454                async_answer_0(call, rc);
    14551455        } else
    1456                 async_answer_0(chandle, ENOTSUP);
     1456                async_answer_0(call, ENOTSUP);
    14571457}
    14581458
    14591459static void remote_nic_get_stats(ddf_fun_t *dev, void *iface,
    1460     cap_call_handle_t chandle, ipc_call_t *call)
     1460    ipc_call_t *call)
    14611461{
    14621462        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    14631463        if (nic_iface->get_stats == NULL) {
    1464                 async_answer_0(chandle, ENOTSUP);
     1464                async_answer_0(call, ENOTSUP);
    14651465                return;
    14661466        }
    … …  
    14711471        errno_t rc = nic_iface->get_stats(dev, &stats);
    14721472        if (rc == EOK) {
    1473                 cap_call_handle_t data_chandle;
     1473                ipc_call_t data;
    14741474                size_t max_len;
    1475                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    1476                         async_answer_0(data_chandle, EINVAL);
    1477                         async_answer_0(chandle, EINVAL);
     1475                if (!async_data_read_receive(&data, &max_len)) {
     1476                        async_answer_0(&data, EINVAL);
     1477                        async_answer_0(call, EINVAL);
    14781478                        return;
    14791479                }
    14801480
    14811481                if (max_len < sizeof(nic_device_stats_t)) {
    1482                         async_answer_0(data_chandle, ELIMIT);
    1483                         async_answer_0(chandle, ELIMIT);
    1484                         return;
    1485                 }
    1486 
    1487                 async_data_read_finalize(data_chandle, &stats,
     1482                        async_answer_0(&data, ELIMIT);
     1483                        async_answer_0(call, ELIMIT);
     1484                        return;
     1485                }
     1486
     1487                async_data_read_finalize(&data, &stats,
    14881488                    sizeof(nic_device_stats_t));
    14891489        }
    14901490
    1491         async_answer_0(chandle, rc);
     1491        async_answer_0(call, rc);
    14921492}
    14931493
    14941494static void remote_nic_get_device_info(ddf_fun_t *dev, void *iface,
    1495     cap_call_handle_t chandle, ipc_call_t *call)
     1495    ipc_call_t *call)
    14961496{
    14971497        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    14981498        if (nic_iface->get_device_info == NULL) {
    1499                 async_answer_0(chandle, ENOTSUP);
     1499                async_answer_0(call, ENOTSUP);
    15001500                return;
    15011501        }
    … …  
    15061506        errno_t rc = nic_iface->get_device_info(dev, &info);
    15071507        if (rc == EOK) {
    1508                 cap_call_handle_t data_chandle;
     1508                ipc_call_t data;
    15091509                size_t max_len;
    1510                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    1511                         async_answer_0(data_chandle, EINVAL);
    1512                         async_answer_0(chandle, EINVAL);
     1510                if (!async_data_read_receive(&data, &max_len)) {
     1511                        async_answer_0(&data, EINVAL);
     1512                        async_answer_0(call, EINVAL);
    15131513                        return;
    15141514                }
    15151515
    15161516                if (max_len < sizeof (nic_device_info_t)) {
    1517                         async_answer_0(data_chandle, ELIMIT);
    1518                         async_answer_0(chandle, ELIMIT);
    1519                         return;
    1520                 }
    1521 
    1522                 async_data_read_finalize(data_chandle, &info,
     1517                        async_answer_0(&data, ELIMIT);
     1518                        async_answer_0(call, ELIMIT);
     1519                        return;
     1520                }
     1521
     1522                async_data_read_finalize(&data, &info,
    15231523                    sizeof(nic_device_info_t));
    15241524        }
    15251525
    1526         async_answer_0(chandle, rc);
     1526        async_answer_0(call, rc);
    15271527}
    15281528
    15291529static void remote_nic_get_cable_state(ddf_fun_t *dev, void *iface,
    1530     cap_call_handle_t chandle, ipc_call_t *call)
     1530    ipc_call_t *call)
    15311531{
    15321532        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15331533        if (nic_iface->get_cable_state == NULL) {
    1534                 async_answer_0(chandle, ENOTSUP);
     1534                async_answer_0(call, ENOTSUP);
    15351535                return;
    15361536        }
    … …  
    15391539
    15401540        errno_t rc = nic_iface->get_cable_state(dev, &cs);
    1541         async_answer_1(chandle, rc, (sysarg_t) cs);
     1541        async_answer_1(call, rc, (sysarg_t) cs);
    15421542}
    15431543
    15441544static void remote_nic_get_operation_mode(ddf_fun_t *dev, void *iface,
    1545     cap_call_handle_t chandle, ipc_call_t *call)
     1545    ipc_call_t *call)
    15461546{
    15471547        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15481548        if (nic_iface->get_operation_mode == NULL) {
    1549                 async_answer_0(chandle, ENOTSUP);
     1549                async_answer_0(call, ENOTSUP);
    15501550                return;
    15511551        }
    … …  
    15561556
    15571557        errno_t rc = nic_iface->get_operation_mode(dev, &speed, &duplex, &role);
    1558         async_answer_3(chandle, rc, (sysarg_t) speed, (sysarg_t) duplex,
     1558        async_answer_3(call, rc, (sysarg_t) speed, (sysarg_t) duplex,
    15591559            (sysarg_t) role);
    15601560}
    15611561
    15621562static void remote_nic_set_operation_mode(ddf_fun_t *dev, void *iface,
    1563     cap_call_handle_t chandle, ipc_call_t *call)
     1563    ipc_call_t *call)
    15641564{
    15651565        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15661566        if (nic_iface->set_operation_mode == NULL) {
    1567                 async_answer_0(chandle, ENOTSUP);
     1567                async_answer_0(call, ENOTSUP);
    15681568                return;
    15691569        }
    … …  
    15741574
    15751575        errno_t rc = nic_iface->set_operation_mode(dev, speed, duplex, role);
    1576         async_answer_0(chandle, rc);
     1576        async_answer_0(call, rc);
    15771577}
    15781578
    15791579static void remote_nic_autoneg_enable(ddf_fun_t *dev, void *iface,
    1580     cap_call_handle_t chandle, ipc_call_t *call)
     1580    ipc_call_t *call)
    15811581{
    15821582        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15831583        if (nic_iface->autoneg_enable == NULL) {
    1584                 async_answer_0(chandle, ENOTSUP);
     1584                async_answer_0(call, ENOTSUP);
    15851585                return;
    15861586        }
    … …  
    15891589
    15901590        errno_t rc = nic_iface->autoneg_enable(dev, advertisement);
    1591         async_answer_0(chandle, rc);
     1591        async_answer_0(call, rc);
    15921592}
    15931593
    15941594static void remote_nic_autoneg_disable(ddf_fun_t *dev, void *iface,
    1595     cap_call_handle_t chandle, ipc_call_t *call)
     1595    ipc_call_t *call)
    15961596{
    15971597        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    15981598        if (nic_iface->autoneg_disable == NULL) {
    1599                 async_answer_0(chandle, ENOTSUP);
     1599                async_answer_0(call, ENOTSUP);
    16001600                return;
    16011601        }
    16021602
    16031603        errno_t rc = nic_iface->autoneg_disable(dev);
    1604         async_answer_0(chandle, rc);
     1604        async_answer_0(call, rc);
    16051605}
    16061606
    16071607static void remote_nic_autoneg_probe(ddf_fun_t *dev, void *iface,
    1608     cap_call_handle_t chandle, ipc_call_t *call)
     1608    ipc_call_t *call)
    16091609{
    16101610        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16111611        if (nic_iface->autoneg_probe == NULL) {
    1612                 async_answer_0(chandle, ENOTSUP);
     1612                async_answer_0(call, ENOTSUP);
    16131613                return;
    16141614        }
    … …  
    16211621        errno_t rc = nic_iface->autoneg_probe(dev, &our_adv, &their_adv, &result,
    16221622            &their_result);
    1623         async_answer_4(chandle, rc, our_adv, their_adv, (sysarg_t) result,
     1623        async_answer_4(call, rc, our_adv, their_adv, (sysarg_t) result,
    16241624            (sysarg_t) their_result);
    16251625}
    16261626
    16271627static void remote_nic_autoneg_restart(ddf_fun_t *dev, void *iface,
    1628     cap_call_handle_t chandle, ipc_call_t *call)
     1628    ipc_call_t *call)
    16291629{
    16301630        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16311631        if (nic_iface->autoneg_restart == NULL) {
    1632                 async_answer_0(chandle, ENOTSUP);
     1632                async_answer_0(call, ENOTSUP);
    16331633                return;
    16341634        }
    16351635
    16361636        errno_t rc = nic_iface->autoneg_restart(dev);
    1637         async_answer_0(chandle, rc);
     1637        async_answer_0(call, rc);
    16381638}
    16391639
    16401640static void remote_nic_get_pause(ddf_fun_t *dev, void *iface,
    1641     cap_call_handle_t chandle, ipc_call_t *call)
     1641    ipc_call_t *call)
    16421642{
    16431643        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16441644        if (nic_iface->get_pause == NULL) {
    1645                 async_answer_0(chandle, ENOTSUP);
     1645                async_answer_0(call, ENOTSUP);
    16461646                return;
    16471647        }
    … …  
    16521652
    16531653        errno_t rc = nic_iface->get_pause(dev, &we_send, &we_receive, &pause);
    1654         async_answer_3(chandle, rc, we_send, we_receive, pause);
     1654        async_answer_3(call, rc, we_send, we_receive, pause);
    16551655}
    16561656
    16571657static void remote_nic_set_pause(ddf_fun_t *dev, void *iface,
    1658     cap_call_handle_t chandle, ipc_call_t *call)
     1658    ipc_call_t *call)
    16591659{
    16601660        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16611661        if (nic_iface->set_pause == NULL) {
    1662                 async_answer_0(chandle, ENOTSUP);
     1662                async_answer_0(call, ENOTSUP);
    16631663                return;
    16641664        }
    … …  
    16701670        errno_t rc = nic_iface->set_pause(dev, allow_send, allow_receive,
    16711671            pause);
    1672         async_answer_0(chandle, rc);
     1672        async_answer_0(call, rc);
    16731673}
    16741674
    16751675static void remote_nic_unicast_get_mode(ddf_fun_t *dev, void *iface,
    1676     cap_call_handle_t chandle, ipc_call_t *call)
     1676    ipc_call_t *call)
    16771677{
    16781678        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    16791679        if (nic_iface->unicast_get_mode == NULL) {
    1680                 async_answer_0(chandle, ENOTSUP);
     1680                async_answer_0(call, ENOTSUP);
    16811681                return;
    16821682        }
    … …  
    16881688                address_list = malloc(max_count * sizeof (nic_address_t));
    16891689                if (!address_list) {
    1690                         async_answer_0(chandle, ENOMEM);
     1690                        async_answer_0(call, ENOMEM);
    16911691                        return;
    16921692                }
    … …  
    17021702        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    17031703                free(address_list);
    1704                 async_answer_2(chandle, rc, mode, address_count);
    1705                 return;
    1706         }
    1707 
    1708         cap_call_handle_t data_chandle;
     1704                async_answer_2(call, rc, mode, address_count);
     1705                return;
     1706        }
     1707
     1708        ipc_call_t data;
    17091709        size_t max_len;
    1710         if (!async_data_read_receive(&data_chandle, &max_len)) {
    1711                 async_answer_0(data_chandle, EINVAL);
    1712                 async_answer_2(chandle, rc, mode, address_count);
     1710        if (!async_data_read_receive(&data, &max_len)) {
     1711                async_answer_0(&data, EINVAL);
     1712                async_answer_2(call, rc, mode, address_count);
    17131713                free(address_list);
    17141714                return;
    … …  
    17211721                max_len = max_count * sizeof(nic_address_t);
    17221722
    1723         async_data_read_finalize(data_chandle, address_list, max_len);
    1724         async_answer_0(data_chandle, EINVAL);
     1723        async_data_read_finalize(&data, address_list, max_len);
    17251724
    17261725        free(address_list);
    1727         async_answer_2(chandle, rc, mode, address_count);
     1726        async_answer_2(call, rc, mode, address_count);
    17281727}
    17291728
    17301729static void remote_nic_unicast_set_mode(ddf_fun_t *dev, void *iface,
    1731     cap_call_handle_t chandle, ipc_call_t *call)
     1730    ipc_call_t *call)
    17321731{
    17331732        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    17391738
    17401739        if (address_count) {
    1741                 cap_call_handle_t data_chandle;
    1742                 if (!async_data_write_receive(&data_chandle, &length)) {
    1743                         async_answer_0(data_chandle, EINVAL);
    1744                         async_answer_0(chandle, EINVAL);
     1740                ipc_call_t data;
     1741                if (!async_data_write_receive(&data, &length)) {
     1742                        async_answer_0(&data, EINVAL);
     1743                        async_answer_0(call, EINVAL);
    17451744                        return;
    17461745                }
    17471746
    17481747                if (length != address_count * sizeof(nic_address_t)) {
    1749                         async_answer_0(data_chandle, ELIMIT);
    1750                         async_answer_0(chandle, ELIMIT);
     1748                        async_answer_0(&data, ELIMIT);
     1749                        async_answer_0(call, ELIMIT);
    17511750                        return;
    17521751                }
    … …  
    17541753                address_list = malloc(length);
    17551754                if (address_list == NULL) {
    1756                         async_answer_0(data_chandle, ENOMEM);
    1757                         async_answer_0(chandle, ENOMEM);
    1758                         return;
    1759                 }
    1760 
    1761                 if (async_data_write_finalize(data_chandle, address_list,
     1755                        async_answer_0(&data, ENOMEM);
     1756                        async_answer_0(call, ENOMEM);
     1757                        return;
     1758                }
     1759
     1760                if (async_data_write_finalize(&data, address_list,
    17621761                    length) != EOK) {
    1763                         async_answer_0(chandle, EINVAL);
     1762                        async_answer_0(call, EINVAL);
    17641763                        free(address_list);
    17651764                        return;
    … …  
    17701769                errno_t rc = nic_iface->unicast_set_mode(dev, mode, address_list,
    17711770                    address_count);
    1772                 async_answer_0(chandle, rc);
     1771                async_answer_0(call, rc);
    17731772        } else
    1774                 async_answer_0(chandle, ENOTSUP);
     1773                async_answer_0(call, ENOTSUP);
    17751774
    17761775        free(address_list);
    … …  
    17781777
    17791778static void remote_nic_multicast_get_mode(ddf_fun_t *dev, void *iface,
    1780     cap_call_handle_t chandle, ipc_call_t *call)
     1779    ipc_call_t *call)
    17811780{
    17821781        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    17831782        if (nic_iface->multicast_get_mode == NULL) {
    1784                 async_answer_0(chandle, ENOTSUP);
     1783                async_answer_0(call, ENOTSUP);
    17851784                return;
    17861785        }
    … …  
    17921791                address_list = malloc(max_count * sizeof(nic_address_t));
    17931792                if (!address_list) {
    1794                         async_answer_0(chandle, ENOMEM);
     1793                        async_answer_0(call, ENOMEM);
    17951794                        return;
    17961795                }
    … …  
    18071806        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    18081807                free(address_list);
    1809                 async_answer_2(chandle, rc, mode, address_count);
    1810                 return;
    1811         }
    1812 
    1813         cap_call_handle_t data_chandle;
     1808                async_answer_2(call, rc, mode, address_count);
     1809                return;
     1810        }
     1811
     1812        ipc_call_t data;
    18141813        size_t max_len;
    1815         if (!async_data_read_receive(&data_chandle, &max_len)) {
    1816                 async_answer_0(data_chandle, EINVAL);
    1817                 async_answer_2(chandle, rc, mode, address_count);
     1814        if (!async_data_read_receive(&data, &max_len)) {
     1815                async_answer_0(&data, EINVAL);
     1816                async_answer_2(call, rc, mode, address_count);
    18181817                free(address_list);
    18191818                return;
    … …  
    18261825                max_len = max_count * sizeof(nic_address_t);
    18271826
    1828         async_data_read_finalize(data_chandle, address_list, max_len);
     1827        async_data_read_finalize(&data, address_list, max_len);
    18291828
    18301829        free(address_list);
    1831         async_answer_2(chandle, rc, mode, address_count);
     1830        async_answer_2(call, rc, mode, address_count);
    18321831}
    18331832
    18341833static void remote_nic_multicast_set_mode(ddf_fun_t *dev, void *iface,
    1835     cap_call_handle_t chandle, ipc_call_t *call)
     1834    ipc_call_t *call)
    18361835{
    18371836        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    18421841
    18431842        if (address_count) {
    1844                 cap_call_handle_t data_chandle;
     1843                ipc_call_t data;
    18451844                size_t length;
    1846                 if (!async_data_write_receive(&data_chandle, &length)) {
    1847                         async_answer_0(data_chandle, EINVAL);
    1848                         async_answer_0(chandle, EINVAL);
     1845                if (!async_data_write_receive(&data, &length)) {
     1846                        async_answer_0(&data, EINVAL);
     1847                        async_answer_0(call, EINVAL);
    18491848                        return;
    18501849                }
    18511850
    18521851                if (length != address_count * sizeof (nic_address_t)) {
    1853                         async_answer_0(data_chandle, ELIMIT);
    1854                         async_answer_0(chandle, ELIMIT);
     1852                        async_answer_0(&data, ELIMIT);
     1853                        async_answer_0(call, ELIMIT);
    18551854                        return;
    18561855                }
    … …  
    18581857                address_list = malloc(length);
    18591858                if (address_list == NULL) {
    1860                         async_answer_0(data_chandle, ENOMEM);
    1861                         async_answer_0(chandle, ENOMEM);
    1862                         return;
    1863                 }
    1864 
    1865                 if (async_data_write_finalize(data_chandle, address_list,
     1859                        async_answer_0(&data, ENOMEM);
     1860                        async_answer_0(call, ENOMEM);
     1861                        return;
     1862                }
     1863
     1864                if (async_data_write_finalize(&data, address_list,
    18661865                    length) != EOK) {
    1867                         async_answer_0(chandle, EINVAL);
     1866                        async_answer_0(call, EINVAL);
    18681867                        free(address_list);
    18691868                        return;
    … …  
    18741873                errno_t rc = nic_iface->multicast_set_mode(dev, mode, address_list,
    18751874                    address_count);
    1876                 async_answer_0(chandle, rc);
     1875                async_answer_0(call, rc);
    18771876        } else
    1878                 async_answer_0(chandle, ENOTSUP);
     1877                async_answer_0(call, ENOTSUP);
    18791878
    18801879        free(address_list);
    … …  
    18821881
    18831882static void remote_nic_broadcast_get_mode(ddf_fun_t *dev, void *iface,
    1884     cap_call_handle_t chandle, ipc_call_t *call)
     1883    ipc_call_t *call)
    18851884{
    18861885        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    18871886        if (nic_iface->broadcast_get_mode == NULL) {
    1888                 async_answer_0(chandle, ENOTSUP);
     1887                async_answer_0(call, ENOTSUP);
    18891888                return;
    18901889        }
    … …  
    18931892
    18941893        errno_t rc = nic_iface->broadcast_get_mode(dev, &mode);
    1895         async_answer_1(chandle, rc, mode);
     1894        async_answer_1(call, rc, mode);
    18961895}
    18971896
    18981897static void remote_nic_broadcast_set_mode(ddf_fun_t *dev, void *iface,
    1899     cap_call_handle_t chandle, ipc_call_t *call)
     1898    ipc_call_t *call)
    19001899{
    19011900        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19021901        if (nic_iface->broadcast_set_mode == NULL) {
    1903                 async_answer_0(chandle, ENOTSUP);
     1902                async_answer_0(call, ENOTSUP);
    19041903                return;
    19051904        }
    … …  
    19081907
    19091908        errno_t rc = nic_iface->broadcast_set_mode(dev, mode);
    1910         async_answer_0(chandle, rc);
     1909        async_answer_0(call, rc);
    19111910}
    19121911
    19131912static void remote_nic_defective_get_mode(ddf_fun_t *dev, void *iface,
    1914     cap_call_handle_t chandle, ipc_call_t *call)
     1913    ipc_call_t *call)
    19151914{
    19161915        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19171916        if (nic_iface->defective_get_mode == NULL) {
    1918                 async_answer_0(chandle, ENOTSUP);
     1917                async_answer_0(call, ENOTSUP);
    19191918                return;
    19201919        }
    … …  
    19231922
    19241923        errno_t rc = nic_iface->defective_get_mode(dev, &mode);
    1925         async_answer_1(chandle, rc, mode);
     1924        async_answer_1(call, rc, mode);
    19261925}
    19271926
    19281927static void remote_nic_defective_set_mode(ddf_fun_t *dev, void *iface,
    1929     cap_call_handle_t chandle, ipc_call_t *call)
     1928    ipc_call_t *call)
    19301929{
    19311930        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19321931        if (nic_iface->defective_set_mode == NULL) {
    1933                 async_answer_0(chandle, ENOTSUP);
     1932                async_answer_0(call, ENOTSUP);
    19341933                return;
    19351934        }
    … …  
    19381937
    19391938        errno_t rc = nic_iface->defective_set_mode(dev, mode);
    1940         async_answer_0(chandle, rc);
     1939        async_answer_0(call, rc);
    19411940}
    19421941
    19431942static void remote_nic_blocked_sources_get(ddf_fun_t *dev, void *iface,
    1944     cap_call_handle_t chandle, ipc_call_t *call)
     1943    ipc_call_t *call)
    19451944{
    19461945        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    19471946        if (nic_iface->blocked_sources_get == NULL) {
    1948                 async_answer_0(chandle, ENOTSUP);
     1947                async_answer_0(call, ENOTSUP);
    19491948                return;
    19501949        }
    … …  
    19561955                address_list = malloc(max_count * sizeof(nic_address_t));
    19571956                if (!address_list) {
    1958                         async_answer_0(chandle, ENOMEM);
     1957                        async_answer_0(call, ENOMEM);
    19591958                        return;
    19601959                }
    … …  
    19681967
    19691968        if ((rc != EOK) || (max_count == 0) || (address_count == 0)) {
    1970                 async_answer_1(chandle, rc, address_count);
     1969                async_answer_1(call, rc, address_count);
    19711970                free(address_list);
    19721971                return;
    19731972        }
    19741973
    1975         cap_call_handle_t data_chandle;
     1974        ipc_call_t data;
    19761975        size_t max_len;
    1977         if (!async_data_read_receive(&data_chandle, &max_len)) {
    1978                 async_answer_0(data_chandle, EINVAL);
    1979                 async_answer_1(chandle, rc, address_count);
     1976        if (!async_data_read_receive(&data, &max_len)) {
     1977                async_answer_0(&data, EINVAL);
     1978                async_answer_1(call, rc, address_count);
    19801979                free(address_list);
    19811980                return;
    … …  
    19881987                max_len = max_count * sizeof(nic_address_t);
    19891988
    1990         async_data_read_finalize(data_chandle, address_list, max_len);
    1991         async_answer_0(data_chandle, EINVAL);
     1989        async_data_read_finalize(&data, address_list, max_len);
    19921990
    19931991        free(address_list);
    1994         async_answer_1(chandle, rc, address_count);
     1992        async_answer_1(call, rc, address_count);
    19951993}
    19961994
    19971995static void remote_nic_blocked_sources_set(ddf_fun_t *dev, void *iface,
    1998     cap_call_handle_t chandle, ipc_call_t *call)
     1996    ipc_call_t *call)
    19991997{
    20001998        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    20052003
    20062004        if (address_count) {
    2007                 cap_call_handle_t data_chandle;
    2008                 if (!async_data_write_receive(&data_chandle, &length)) {
    2009                         async_answer_0(data_chandle, EINVAL);
    2010                         async_answer_0(chandle, EINVAL);
     2005                ipc_call_t data;
     2006                if (!async_data_write_receive(&data, &length)) {
     2007                        async_answer_0(&data, EINVAL);
     2008                        async_answer_0(call, EINVAL);
    20112009                        return;
    20122010                }
    20132011
    20142012                if (length != address_count * sizeof(nic_address_t)) {
    2015                         async_answer_0(data_chandle, ELIMIT);
    2016                         async_answer_0(chandle, ELIMIT);
     2013                        async_answer_0(&data, ELIMIT);
     2014                        async_answer_0(call, ELIMIT);
    20172015                        return;
    20182016                }
    … …  
    20202018                address_list = malloc(length);
    20212019                if (address_list == NULL) {
    2022                         async_answer_0(data_chandle, ENOMEM);
    2023                         async_answer_0(chandle, ENOMEM);
    2024                         return;
    2025                 }
    2026 
    2027                 if (async_data_write_finalize(data_chandle, address_list,
     2020                        async_answer_0(&data, ENOMEM);
     2021                        async_answer_0(call, ENOMEM);
     2022                        return;
     2023                }
     2024
     2025                if (async_data_write_finalize(&data, address_list,
    20282026                    length) != EOK) {
    2029                         async_answer_0(chandle, EINVAL);
     2027                        async_answer_0(call, EINVAL);
    20302028                        free(address_list);
    20312029                        return;
    … …  
    20362034                errno_t rc = nic_iface->blocked_sources_set(dev, address_list,
    20372035                    address_count);
    2038                 async_answer_0(chandle, rc);
     2036                async_answer_0(call, rc);
    20392037        } else
    2040                 async_answer_0(chandle, ENOTSUP);
     2038                async_answer_0(call, ENOTSUP);
    20412039
    20422040        free(address_list);
    … …  
    20442042
    20452043static void remote_nic_vlan_get_mask(ddf_fun_t *dev, void *iface,
    2046     cap_call_handle_t chandle, ipc_call_t *call)
     2044    ipc_call_t *call)
    20472045{
    20482046        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    20492047        if (nic_iface->vlan_get_mask == NULL) {
    2050                 async_answer_0(chandle, ENOTSUP);
     2048                async_answer_0(call, ENOTSUP);
    20512049                return;
    20522050        }
    … …  
    20572055        errno_t rc = nic_iface->vlan_get_mask(dev, &vlan_mask);
    20582056        if (rc == EOK) {
    2059                 cap_call_handle_t data_chandle;
     2057                ipc_call_t data;
    20602058                size_t max_len;
    2061                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    2062                         async_answer_0(data_chandle, EINVAL);
    2063                         async_answer_0(chandle, EINVAL);
     2059                if (!async_data_read_receive(&data, &max_len)) {
     2060                        async_answer_0(&data, EINVAL);
     2061                        async_answer_0(call, EINVAL);
    20642062                        return;
    20652063                }
    20662064
    20672065                if (max_len != sizeof(nic_vlan_mask_t)) {
    2068                         async_answer_0(data_chandle, EINVAL);
    2069                         async_answer_0(chandle, EINVAL);
    2070                         return;
    2071                 }
    2072 
    2073                 async_data_read_finalize(data_chandle, &vlan_mask, max_len);
    2074         }
    2075 
    2076         async_answer_0(chandle, rc);
     2066                        async_answer_0(&data, EINVAL);
     2067                        async_answer_0(call, EINVAL);
     2068                        return;
     2069                }
     2070
     2071                async_data_read_finalize(&data, &vlan_mask, max_len);
     2072        }
     2073
     2074        async_answer_0(call, rc);
    20772075}
    20782076
    20792077static void remote_nic_vlan_set_mask(ddf_fun_t *dev, void *iface,
    2080     cap_call_handle_t chandle, ipc_call_t *call)
     2078    ipc_call_t *call)
    20812079{
    20822080        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    20872085
    20882086        if (vlan_mask_set) {
    2089                 cap_call_handle_t data_chandle;
     2087                ipc_call_t data;
    20902088                size_t length;
    2091                 if (!async_data_write_receive(&data_chandle, &length)) {
    2092                         async_answer_0(data_chandle, EINVAL);
    2093                         async_answer_0(chandle, EINVAL);
     2089                if (!async_data_write_receive(&data, &length)) {
     2090                        async_answer_0(&data, EINVAL);
     2091                        async_answer_0(call, EINVAL);
    20942092                        return;
    20952093                }
    20962094
    20972095                if (length != sizeof(nic_vlan_mask_t)) {
    2098                         async_answer_0(data_chandle, ELIMIT);
    2099                         async_answer_0(chandle, ELIMIT);
    2100                         return;
    2101                 }
    2102 
    2103                 if (async_data_write_finalize(data_chandle, &vlan_mask,
     2096                        async_answer_0(&data, ELIMIT);
     2097                        async_answer_0(call, ELIMIT);
     2098                        return;
     2099                }
     2100
     2101                if (async_data_write_finalize(&data, &vlan_mask,
    21042102                    length) != EOK) {
    2105                         async_answer_0(chandle, EINVAL);
     2103                        async_answer_0(call, EINVAL);
    21062104                        return;
    21072105                }
    … …  
    21122110        if (nic_iface->vlan_set_mask != NULL) {
    21132111                errno_t rc = nic_iface->vlan_set_mask(dev, vlan_mask_pointer);
    2114                 async_answer_0(chandle, rc);
     2112                async_answer_0(call, rc);
    21152113        } else
    2116                 async_answer_0(chandle, ENOTSUP);
     2114                async_answer_0(call, ENOTSUP);
    21172115}
    21182116
    21192117static void remote_nic_vlan_set_tag(ddf_fun_t *dev, void *iface,
    2120     cap_call_handle_t chandle, ipc_call_t *call)
     2118    ipc_call_t *call)
    21212119{
    21222120        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21232121
    21242122        if (nic_iface->vlan_set_tag == NULL) {
    2125                 async_answer_0(chandle, ENOTSUP);
     2123                async_answer_0(call, ENOTSUP);
    21262124                return;
    21272125        }
    … …  
    21322130
    21332131        errno_t rc = nic_iface->vlan_set_tag(dev, tag, add, strip);
    2134         async_answer_0(chandle, rc);
     2132        async_answer_0(call, rc);
    21352133}
    21362134
    21372135static void remote_nic_wol_virtue_add(ddf_fun_t *dev, void *iface,
    2138     cap_call_handle_t chandle, ipc_call_t *call)
     2136    ipc_call_t *call)
    21392137{
    21402138        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21412139
    21422140        int send_data = (int) IPC_GET_ARG3(*call);
    2143         cap_call_handle_t data_chandle;
     2141        ipc_call_t data;
    21442142
    21452143        if (nic_iface->wol_virtue_add == NULL) {
    21462144                if (send_data) {
    2147                         async_data_write_receive(&data_chandle, NULL);
    2148                         async_answer_0(data_chandle, ENOTSUP);
    2149                 }
    2150 
    2151                 async_answer_0(chandle, ENOTSUP);
     2145                        async_data_write_receive(&data, NULL);
     2146                        async_answer_0(&data, ENOTSUP);
     2147                }
     2148
     2149                async_answer_0(call, ENOTSUP);
    21522150        }
    21532151
    21542152        size_t length = 0;
    2155         void *data = NULL;
     2153        void *virtue = NULL;
    21562154
    21572155        if (send_data) {
    2158                 if (!async_data_write_receive(&data_chandle, &length)) {
    2159                         async_answer_0(data_chandle, EINVAL);
    2160                         async_answer_0(chandle, EINVAL);
    2161                         return;
    2162                 }
    2163 
    2164                 data = malloc(length);
    2165                 if (data == NULL) {
    2166                         async_answer_0(data_chandle, ENOMEM);
    2167                         async_answer_0(chandle, ENOMEM);
    2168                         return;
    2169                 }
    2170 
    2171                 if (async_data_write_finalize(data_chandle, data,
     2156                if (!async_data_write_receive(&data, &length)) {
     2157                        async_answer_0(&data, EINVAL);
     2158                        async_answer_0(call, EINVAL);
     2159                        return;
     2160                }
     2161
     2162                virtue = malloc(length);
     2163                if (virtue == NULL) {
     2164                        async_answer_0(&data, ENOMEM);
     2165                        async_answer_0(call, ENOMEM);
     2166                        return;
     2167                }
     2168
     2169                if (async_data_write_finalize(&data, virtue,
    21722170                    length) != EOK) {
    2173                         async_answer_0(chandle, EINVAL);
    2174                         free(data);
     2171                        async_answer_0(call, EINVAL);
     2172                        free(virtue);
    21752173                        return;
    21762174                }
    … …  
    21802178        nic_wv_type_t type = (nic_wv_type_t) IPC_GET_ARG2(*call);
    21812179
    2182         errno_t rc = nic_iface->wol_virtue_add(dev, type, data, length, &id);
    2183         async_answer_1(chandle, rc, (sysarg_t) id);
    2184         free(data);
     2180        errno_t rc = nic_iface->wol_virtue_add(dev, type, virtue, length, &id);
     2181        async_answer_1(call, rc, (sysarg_t) id);
     2182        free(virtue);
    21852183}
    21862184
    21872185static void remote_nic_wol_virtue_remove(ddf_fun_t *dev, void *iface,
    2188     cap_call_handle_t chandle, ipc_call_t *call)
     2186    ipc_call_t *call)
    21892187{
    21902188        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    21912189
    21922190        if (nic_iface->wol_virtue_remove == NULL) {
    2193                 async_answer_0(chandle, ENOTSUP);
     2191                async_answer_0(call, ENOTSUP);
    21942192                return;
    21952193        }
    … …  
    21982196
    21992197        errno_t rc = nic_iface->wol_virtue_remove(dev, id);
    2200         async_answer_0(chandle, rc);
     2198        async_answer_0(call, rc);
    22012199}
    22022200
    22032201static void remote_nic_wol_virtue_probe(ddf_fun_t *dev, void *iface,
    2204     cap_call_handle_t chandle, ipc_call_t *call)
     2202    ipc_call_t *call)
    22052203{
    22062204        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    22072205
    22082206        if (nic_iface->wol_virtue_probe == NULL) {
    2209                 async_answer_0(chandle, ENOTSUP);
     2207                async_answer_0(call, ENOTSUP);
    22102208                return;
    22112209        }
    … …  
    22152213        nic_wv_type_t type = NIC_WV_NONE;
    22162214        size_t length = 0;
    2217         cap_call_handle_t data_chandle;
    2218         void *data = NULL;
     2215        ipc_call_t data;
     2216        void *virtue = NULL;
    22192217
    22202218        if (max_length != 0) {
    2221                 data = malloc(max_length);
    2222                 if (data == NULL) {
    2223                         async_answer_0(chandle, ENOMEM);
    2224                         return;
    2225                 }
    2226         }
    2227 
    2228         memset(data, 0, max_length);
     2219                virtue = malloc(max_length);
     2220                if (virtue == NULL) {
     2221                        async_answer_0(call, ENOMEM);
     2222                        return;
     2223                }
     2224        }
     2225
     2226        memset(virtue, 0, max_length);
    22292227
    22302228        errno_t rc = nic_iface->wol_virtue_probe(dev, id, &type, max_length,
    2231             data, &length);
     2229            virtue, &length);
    22322230
    22332231        if ((max_length != 0) && (length != 0)) {
    22342232                size_t req_length;
    2235                 if (!async_data_read_receive(&data_chandle, &req_length)) {
    2236                         async_answer_0(data_chandle, EINVAL);
    2237                         async_answer_0(chandle, EINVAL);
    2238                         free(data);
     2233                if (!async_data_read_receive(&data, &req_length)) {
     2234                        async_answer_0(&data, EINVAL);
     2235                        async_answer_0(call, EINVAL);
     2236                        free(virtue);
    22392237                        return;
    22402238                }
    … …  
    22462244                        req_length = max_length;
    22472245
    2248                 async_data_read_finalize(data_chandle, data, req_length);
    2249         }
    2250 
    2251         async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) length);
    2252         free(data);
     2246                async_data_read_finalize(&data, virtue, req_length);
     2247        }
     2248
     2249        async_answer_2(call, rc, (sysarg_t) type, (sysarg_t) length);
     2250        free(virtue);
    22532251}
    22542252
    22552253static void remote_nic_wol_virtue_list(ddf_fun_t *dev, void *iface,
    2256     cap_call_handle_t chandle, ipc_call_t *call)
     2254    ipc_call_t *call)
    22572255{
    22582256        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    22592257        if (nic_iface->wol_virtue_list == NULL) {
    2260                 async_answer_0(chandle, ENOTSUP);
     2258                async_answer_0(call, ENOTSUP);
    22612259                return;
    22622260        }
    … …  
    22662264        size_t count = 0;
    22672265        nic_wv_id_t *id_list = NULL;
    2268         cap_call_handle_t data_chandle;
     2266        ipc_call_t data;
    22692267
    22702268        if (max_count != 0) {
    22712269                id_list = malloc(max_count * sizeof(nic_wv_id_t));
    22722270                if (id_list == NULL) {
    2273                         async_answer_0(chandle, ENOMEM);
     2271                        async_answer_0(call, ENOMEM);
    22742272                        return;
    22752273                }
    … …  
    22832281        if ((max_count != 0) && (count != 0)) {
    22842282                size_t req_length;
    2285                 if (!async_data_read_receive(&data_chandle, &req_length)) {
    2286                         async_answer_0(data_chandle, EINVAL);
    2287                         async_answer_0(chandle, EINVAL);
     2283                if (!async_data_read_receive(&data, &req_length)) {
     2284                        async_answer_0(&data, EINVAL);
     2285                        async_answer_0(call, EINVAL);
    22882286                        free(id_list);
    22892287                        return;
    … …  
    22962294                        req_length = max_count * sizeof(nic_wv_id_t);
    22972295
    2298                 rc = async_data_read_finalize(data_chandle, id_list, req_length);
    2299         }
    2300 
    2301         async_answer_1(chandle, rc, (sysarg_t) count);
     2296                rc = async_data_read_finalize(&data, id_list, req_length);
     2297        }
     2298
     2299        async_answer_1(call, rc, (sysarg_t) count);
    23022300        free(id_list);
    23032301}
    23042302
    23052303static void remote_nic_wol_virtue_get_caps(ddf_fun_t *dev, void *iface,
    2306     cap_call_handle_t chandle, ipc_call_t *call)
     2304    ipc_call_t *call)
    23072305{
    23082306        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23092307        if (nic_iface->wol_virtue_get_caps == NULL) {
    2310                 async_answer_0(chandle, ENOTSUP);
     2308                async_answer_0(call, ENOTSUP);
    23112309                return;
    23122310        }
    … …  
    23162314
    23172315        errno_t rc = nic_iface->wol_virtue_get_caps(dev, type, &count);
    2318         async_answer_1(chandle, rc, (sysarg_t) count);
     2316        async_answer_1(call, rc, (sysarg_t) count);
    23192317}
    23202318
    23212319static void remote_nic_wol_load_info(ddf_fun_t *dev, void *iface,
    2322     cap_call_handle_t chandle, ipc_call_t *call)
     2320    ipc_call_t *call)
    23232321{
    23242322        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23252323        if (nic_iface->wol_load_info == NULL) {
    2326                 async_answer_0(chandle, ENOTSUP);
     2324                async_answer_0(call, ENOTSUP);
    23272325                return;
    23282326        }
    … …  
    23312329        size_t frame_length = 0;
    23322330        nic_wv_type_t type = NIC_WV_NONE;
    2333         uint8_t *data = NULL;
     2331        uint8_t *info = NULL;
    23342332
    23352333        if (max_length != 0) {
    2336                 data = malloc(max_length);
    2337                 if (data == NULL) {
    2338                         async_answer_0(chandle, ENOMEM);
    2339                         return;
    2340                 }
    2341         }
    2342 
    2343         memset(data, 0, max_length);
    2344 
    2345         errno_t rc = nic_iface->wol_load_info(dev, &type, max_length, data,
     2334                info = malloc(max_length);
     2335                if (info == NULL) {
     2336                        async_answer_0(call, ENOMEM);
     2337                        return;
     2338                }
     2339        }
     2340
     2341        memset(info, 0, max_length);
     2342
     2343        errno_t rc = nic_iface->wol_load_info(dev, &type, max_length, info,
    23462344            &frame_length);
    23472345        if (rc == EOK) {
    2348                 cap_call_handle_t data_chandle;
     2346                ipc_call_t data;
    23492347                size_t req_length;
    2350                 if (!async_data_read_receive(&data_chandle, &req_length)) {
    2351                         async_answer_0(data_chandle, EINVAL);
    2352                         async_answer_0(chandle, EINVAL);
    2353                         free(data);
     2348                if (!async_data_read_receive(&data, &req_length)) {
     2349                        async_answer_0(&data, EINVAL);
     2350                        async_answer_0(call, EINVAL);
     2351                        free(info);
    23542352                        return;
    23552353                }
    … …  
    23572355                req_length = req_length > max_length ? max_length : req_length;
    23582356                req_length = req_length > frame_length ? frame_length : req_length;
    2359                 async_data_read_finalize(data_chandle, data, req_length);
    2360         }
    2361 
    2362         async_answer_2(chandle, rc, (sysarg_t) type, (sysarg_t) frame_length);
    2363         free(data);
     2357                async_data_read_finalize(&data, info, req_length);
     2358        }
     2359
     2360        async_answer_2(call, rc, (sysarg_t) type, (sysarg_t) frame_length);
     2361        free(info);
    23642362}
    23652363
    23662364static void remote_nic_offload_probe(ddf_fun_t *dev, void *iface,
    2367     cap_call_handle_t chandle, ipc_call_t *call)
     2365    ipc_call_t *call)
    23682366{
    23692367        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23702368        if (nic_iface->offload_probe == NULL) {
    2371                 async_answer_0(chandle, ENOTSUP);
     2369                async_answer_0(call, ENOTSUP);
    23722370                return;
    23732371        }
    … …  
    23772375
    23782376        errno_t rc = nic_iface->offload_probe(dev, &supported, &active);
    2379         async_answer_2(chandle, rc, supported, active);
     2377        async_answer_2(call, rc, supported, active);
    23802378}
    23812379
    23822380static void remote_nic_offload_set(ddf_fun_t *dev, void *iface,
    2383     cap_call_handle_t chandle, ipc_call_t *call)
     2381    ipc_call_t *call)
    23842382{
    23852383        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    23862384        if (nic_iface->offload_set == NULL) {
    2387                 async_answer_0(chandle, ENOTSUP);
     2385                async_answer_0(call, ENOTSUP);
    23882386                return;
    23892387        }
    … …  
    23932391
    23942392        errno_t rc = nic_iface->offload_set(dev, mask, active);
    2395         async_answer_0(chandle, rc);
     2393        async_answer_0(call, rc);
    23962394}
    23972395
    23982396static void remote_nic_poll_get_mode(ddf_fun_t *dev, void *iface,
    2399     cap_call_handle_t chandle, ipc_call_t *call)
     2397    ipc_call_t *call)
    24002398{
    24012399        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    24022400        if (nic_iface->poll_get_mode == NULL) {
    2403                 async_answer_0(chandle, ENOTSUP);
     2401                async_answer_0(call, ENOTSUP);
    24042402                return;
    24052403        }
    … …  
    24142412        errno_t rc = nic_iface->poll_get_mode(dev, &mode, &period);
    24152413        if ((rc == EOK) && (request_data)) {
     2414                ipc_call_t data;
    24162415                size_t max_len;
    2417                 cap_call_handle_t data_chandle;
    2418 
    2419                 if (!async_data_read_receive(&data_chandle, &max_len)) {
    2420                         async_answer_0(data_chandle, EINVAL);
    2421                         async_answer_0(chandle, EINVAL);
     2416
     2417                if (!async_data_read_receive(&data, &max_len)) {
     2418                        async_answer_0(&data, EINVAL);
     2419                        async_answer_0(call, EINVAL);
    24222420                        return;
    24232421                }
    24242422
    24252423                if (max_len != sizeof(struct timeval)) {
    2426                         async_answer_0(data_chandle, ELIMIT);
    2427                         async_answer_0(chandle, ELIMIT);
    2428                         return;
    2429                 }
    2430 
    2431                 async_data_read_finalize(data_chandle, &period,
     2424                        async_answer_0(&data, ELIMIT);
     2425                        async_answer_0(call, ELIMIT);
     2426                        return;
     2427                }
     2428
     2429                async_data_read_finalize(&data, &period,
    24322430                    sizeof(struct timeval));
    24332431        }
    24342432
    2435         async_answer_1(chandle, rc, (sysarg_t) mode);
     2433        async_answer_1(call, rc, (sysarg_t) mode);
    24362434}
    24372435
    24382436static void remote_nic_poll_set_mode(ddf_fun_t *dev, void *iface,
    2439     cap_call_handle_t chandle, ipc_call_t *call)
     2437    ipc_call_t *call)
    24402438{
    24412439        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    … …  
    24482446
    24492447        if (has_period) {
    2450                 cap_call_handle_t data_chandle;
    2451                 if (!async_data_write_receive(&data_chandle, &length)) {
    2452                         async_answer_0(data_chandle, EINVAL);
    2453                         async_answer_0(chandle, EINVAL);
     2448                ipc_call_t data;
     2449                if (!async_data_write_receive(&data, &length)) {
     2450                        async_answer_0(&data, EINVAL);
     2451                        async_answer_0(call, EINVAL);
    24542452                        return;
    24552453                }
    24562454
    24572455                if (length != sizeof(struct timeval)) {
    2458                         async_answer_0(data_chandle, ELIMIT);
    2459                         async_answer_0(chandle, ELIMIT);
     2456                        async_answer_0(&data, ELIMIT);
     2457                        async_answer_0(call, ELIMIT);
    24602458                        return;
    24612459                }
    24622460
    24632461                period = &period_buf;
    2464                 if (async_data_write_finalize(data_chandle, period,
     2462                if (async_data_write_finalize(&data, period,
    24652463                    length) != EOK) {
    2466                         async_answer_0(chandle, EINVAL);
     2464                        async_answer_0(call, EINVAL);
    24672465                        return;
    24682466                }
    … …  
    24712469        if (nic_iface->poll_set_mode != NULL) {
    24722470                errno_t rc = nic_iface->poll_set_mode(dev, mode, period);
    2473                 async_answer_0(chandle, rc);
     2471                async_answer_0(call, rc);
    24742472        } else
    2475                 async_answer_0(chandle, ENOTSUP);
     2473                async_answer_0(call, ENOTSUP);
    24762474}
    24772475
    24782476static void remote_nic_poll_now(ddf_fun_t *dev, void *iface,
    2479     cap_call_handle_t chandle, ipc_call_t *call)
     2477    ipc_call_t *call)
    24802478{
    24812479        nic_iface_t *nic_iface = (nic_iface_t *) iface;
    24822480        if (nic_iface->poll_now == NULL) {
    2483                 async_answer_0(chandle, ENOTSUP);
     2481                async_answer_0(call, ENOTSUP);
    24842482                return;
    24852483        }
    24862484
    24872485        errno_t rc = nic_iface->poll_now(dev);
    2488         async_answer_0(chandle, rc);
     2486        async_answer_0(call, rc);
    24892487}
    24902488
Note: See TracChangeset for help on using the changeset viewer.