source: mainline/uspace/app/nic/nic.c@ 338d54a7

/*
 * Copyright (c) 2014 Jiri Svoboda
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup nic
 * @{
 */
/** @file NIC configuration utility.
 *
 */

#include <errno.h>
#include <loc.h>
#include <nic_iface.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <str.h>
#include <str_error.h>

#define NAME  "nic"

typedef struct {
        nic_device_info_t device_info;
        nic_address_t address;
        nic_cable_state_t link_state;
        nic_channel_mode_t duplex;
        nic_unicast_mode_t unicast_mode;
        nic_multicast_mode_t multicast_mode;
        nic_broadcast_mode_t broadcast_mode;
        int speed;
} nic_info_t;

static void print_syntax(void)
{
        printf("syntax:\n");
        printf("\t" NAME " [<index> <cmd> [<args...>]]\n");
        printf("\t<index> is NIC index number reported by the tool\n");
        printf("\t<cmd> is:\n");
        printf("\taddr <mac_address> - set MAC address\n");
        printf("\tspeed <10|100|1000> - set NIC speed\n");
        printf("\tduplex <half|full|simplex> - set duplex mode\n");
        printf("\tauto - enable autonegotiation\n");
        printf("\tunicast <block|default|list|promisc> - set unicast receive filtering\n");
        printf("\tmulticast <block|list|promisc> - set multicast receive filtering\n");
        printf("\tbroadcast <block|allow> - block or allow incoming broadcast frames\n");
}

static async_sess_t *get_nic_by_index(size_t i)
{
        errno_t rc;
        size_t count;
        char *svc_name;
        category_id_t nic_cat;
        service_id_t *nics = NULL;
        async_sess_t *sess;

        rc = loc_category_get_id("nic", &nic_cat, 0);
        if (rc != EOK) {
                printf("Error resolving category 'nic'.\n");
                goto error;
        }

        rc = loc_category_get_svcs(nic_cat, &nics, &count);
        if (rc != EOK) {
                printf("Error getting list of NICs.\n");
                goto error;
        }

        rc = loc_service_get_name(nics[i], &svc_name);
        if (rc != EOK) {
                printf("Error getting service name.\n");
                goto error;
        }

        printf("Using device: %s\n", svc_name);

        sess = loc_service_connect(nics[i], INTERFACE_DDF, 0);
        if (sess == NULL) {
                printf("Error connecting to service.\n");
                goto error;
        }

        return sess;
error:
        return NULL;
}

static errno_t nic_get_info(service_id_t svc_id, char *svc_name,
    nic_info_t *info)
{
        async_sess_t *sess;
        nic_role_t role;
        errno_t rc;

        sess = loc_service_connect(svc_id, INTERFACE_DDF, 0);
        if (sess == NULL) {
                printf("Error connecting to service.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_get_address(sess, &info->address);
        if (rc != EOK) {
                printf("Error getting NIC address.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_get_device_info(sess, &info->device_info);
        if (rc != EOK) {
                printf("Error getting NIC device info.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_get_cable_state(sess, &info->link_state);
        if (rc != EOK) {
                printf("Error getting link state.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_get_operation_mode(sess, &info->speed, &info->duplex, &role);
        if (rc != EOK) {
                printf("Error getting NIC speed and duplex mode.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_unicast_get_mode(sess, &info->unicast_mode, 0, NULL, NULL);
        if (rc != EOK) {
                printf("Error gettinc NIC unicast receive mode.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_multicast_get_mode(sess, &info->multicast_mode, 0, NULL, NULL);
        if (rc != EOK) {
                printf("Error gettinc NIC multicast receive mode.\n");
                rc = EIO;
                goto error;
        }

        rc = nic_broadcast_get_mode(sess, &info->broadcast_mode);
        if (rc != EOK) {
                printf("Error gettinc NIC broadcast receive mode.\n");
                rc = EIO;
                goto error;
        }

        return EOK;
error:
        return rc;
}

static const char *nic_link_state_str(nic_cable_state_t link_state)
{
        switch (link_state) {
        case NIC_CS_UNKNOWN: return "unknown";
        case NIC_CS_PLUGGED: return "up";
        case NIC_CS_UNPLUGGED: return "down";
        default: assert(false); return NULL;
        }
}

static const char *nic_duplex_mode_str(nic_channel_mode_t mode)
{
        switch (mode) {
        case NIC_CM_FULL_DUPLEX: return "full-duplex";
        case NIC_CM_HALF_DUPLEX: return "half-duplex";
        case NIC_CM_SIMPLEX: return "simplex";
        default: assert(false); return NULL;
        }
}

static const char *nic_unicast_mode_str(nic_unicast_mode_t mode)
{
        switch (mode) {
        case NIC_UNICAST_UNKNOWN: return "unknown";
        case NIC_UNICAST_BLOCKED: return "blocked";
        case NIC_UNICAST_DEFAULT: return "default";
        case NIC_UNICAST_LIST: return "list";
        case NIC_UNICAST_PROMISC: return "promisc";
        default: assert(false); return NULL;
        }
}

static const char *nic_multicast_mode_str(nic_multicast_mode_t mode)
{
        switch (mode) {
        case NIC_MULTICAST_UNKNOWN: return "unknown";
        case NIC_MULTICAST_BLOCKED: return "blocked";
        case NIC_MULTICAST_LIST: return "list";
        case NIC_MULTICAST_PROMISC: return "promisc";
        default: assert(false); return NULL;
        }
}

static const char *nic_broadcast_mode_str(nic_broadcast_mode_t mode)
{
        switch (mode) {
        case NIC_BROADCAST_UNKNOWN: return "unknown";
        case NIC_BROADCAST_BLOCKED: return "blocked";
        case NIC_BROADCAST_ACCEPTED: return "accepted";
        default: assert(false); return NULL;
        }
}

static char *nic_addr_format(nic_address_t *a)
{
        int rc;
        char *s;

        rc = asprintf(&s, "%02x:%02x:%02x:%02x:%02x:%02x",
            a->address[0], a->address[1], a->address[2],
            a->address[3], a->address[4], a->address[5]);
        if (rc < 0)
                return NULL;

        return s;
}

static errno_t nic_list(void)
{
        category_id_t nic_cat;
        service_id_t *nics = NULL;
        nic_info_t nic_info;
        size_t count, i;
        char *svc_name;
        char *addr_str;
        errno_t rc;

        rc = loc_category_get_id("nic", &nic_cat, 0);
        if (rc != EOK) {
                printf("Error resolving category 'nic'.\n");
                goto error;
        }

        rc = loc_category_get_svcs(nic_cat, &nics, &count);
        if (rc != EOK) {
                printf("Error getting list of NICs.\n");
                goto error;
        }

        printf("[Index]: [Service Name]\n");
        for (i = 0; i < count; i++) {
                rc = loc_service_get_name(nics[i], &svc_name);
                if (rc != EOK) {
                        printf("Error getting service name.\n");
                        goto error;
                }

                rc = nic_get_info(nics[i], svc_name, &nic_info);
                if (rc != EOK)
                        goto error;

                addr_str = nic_addr_format(&nic_info.address);
                if (addr_str == NULL) {
                        printf("Out of memory.\n");
                        rc = ENOMEM;
                        goto error;
                }

                printf("%zu: %s\n", i, svc_name);
                printf("\tMAC address: %s\n", addr_str);
                printf("\tVendor name: %s\n",
                    nic_info.device_info.vendor_name);
                printf("\tModel name: %s\n",
                    nic_info.device_info.model_name);
                printf("\tLink state: %s\n",
                    nic_link_state_str(nic_info.link_state));
                printf("\tUnicast receive mode: %s\n",
                    nic_unicast_mode_str(nic_info.unicast_mode));
                printf("\tMulticast receive mode: %s\n",
                    nic_multicast_mode_str(nic_info.multicast_mode));
                printf("\tBroadcast receive mode: %s\n",
                    nic_broadcast_mode_str(nic_info.broadcast_mode));

                if (nic_info.link_state == NIC_CS_PLUGGED) {
                        printf("\tSpeed: %dMbps %s\n", nic_info.speed,
                            nic_duplex_mode_str(nic_info.duplex));
                }

                free(svc_name);
                free(addr_str);
        }

        return EOK;
error:
        free(nics);
        return rc;
}

static errno_t nic_set_speed(int i, char *str)
{
        async_sess_t *sess;
        uint32_t speed;
        int oldspeed;
        nic_channel_mode_t oldduplex;
        nic_role_t oldrole;
        errno_t rc;

        rc = str_uint32_t(str, NULL, 10, false, &speed);
        if (rc != EOK) {
                printf("Speed must be a numeric value.\n");
                return rc;
        }

        if (speed != 10 && speed != 100 && speed != 1000) {
                printf("Speed must be one of: 10, 100, 1000.\n");
                return EINVAL;
        }

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        rc = nic_get_operation_mode(sess, &oldspeed, &oldduplex, &oldrole);
        if (rc != EOK) {
                printf("Error getting NIC speed and duplex mode.\n");
                return EIO;
        }

        return nic_set_operation_mode(sess, speed, oldduplex, oldrole);
}

static errno_t nic_set_duplex(int i, char *str)
{
        async_sess_t *sess;
        int oldspeed;
        nic_channel_mode_t duplex = NIC_CM_UNKNOWN;
        nic_channel_mode_t oldduplex;
        nic_role_t oldrole;
        errno_t rc;

        if (!str_cmp(str, "half"))
                duplex = NIC_CM_HALF_DUPLEX;

        if (!str_cmp(str, "full"))
                duplex = NIC_CM_FULL_DUPLEX;

        if (!str_cmp(str, "simplex"))
                duplex = NIC_CM_SIMPLEX;

        if (duplex == NIC_CM_UNKNOWN) {
                printf("Invalid duplex specification.\n");
                return EINVAL;
        }

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        rc = nic_get_operation_mode(sess, &oldspeed, &oldduplex, &oldrole);
        if (rc != EOK) {
                printf("Error getting NIC speed and duplex mode.\n");
                return EIO;
        }

        return nic_set_operation_mode(sess, oldspeed, duplex, oldrole);
}

static errno_t nic_set_autoneg(int i)
{
        async_sess_t *sess;
        errno_t rc;

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        rc = nic_autoneg_restart(sess);
        if (rc != EOK) {
                printf("Error restarting NIC autonegotiation.\n");
                return EIO;
        }

        return EOK;
}

static errno_t nic_set_addr(int i, char *str)
{
        async_sess_t *sess;
        nic_address_t addr;
        errno_t rc;
        int idx;

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        if (str_size(str) != 17) {
                printf("Invalid MAC address specified");
                return EINVAL;
        }

        for (idx = 0; idx < 6; idx++) {
                rc = str_uint8_t(&str[idx * 3], NULL, 16, false, &addr.address[idx]);
                if (rc != EOK) {
                        printf("Invalid MAC address specified");
                        return EINVAL;
                }
        }

        return nic_set_address(sess, &addr);
}

static errno_t nic_set_rx_unicast(int i, char *str)
{
        async_sess_t *sess;

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        if (!str_cmp(str, "block")) {
                nic_unicast_set_mode(sess, NIC_UNICAST_BLOCKED, NULL, 0);
                return EOK;
        }

        if (!str_cmp(str, "default")) {
                nic_unicast_set_mode(sess, NIC_UNICAST_DEFAULT, NULL, 0);
                return EOK;
        }

        if (!str_cmp(str, "list")) {
                nic_unicast_set_mode(sess, NIC_UNICAST_LIST, NULL, 0);
                return EOK;
        }

        if (!str_cmp(str, "promisc")) {
                nic_unicast_set_mode(sess, NIC_UNICAST_PROMISC, NULL, 0);
                return EOK;
        }


        printf("Invalid pameter - should be one of: block, default, promisc\n");
        return EINVAL;
}

static errno_t nic_set_rx_multicast(int i, char *str)
{
        async_sess_t *sess;

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        if (!str_cmp(str, "block")) {
                nic_multicast_set_mode(sess, NIC_MULTICAST_BLOCKED, NULL, 0);
                return EOK;
        }

        if (!str_cmp(str, "list")) {
                nic_multicast_set_mode(sess, NIC_MULTICAST_LIST, NULL, 0);
                return EOK;
        }

        if (!str_cmp(str, "promisc")) {
                nic_multicast_set_mode(sess, NIC_MULTICAST_PROMISC, NULL, 0);
                return EOK;
        }

        printf("Invalid pameter - should be one of: block, promisc\n");
        return EINVAL;
}

static errno_t nic_set_rx_broadcast(int i, char *str)
{
        async_sess_t *sess;

        sess = get_nic_by_index(i);
        if (sess == NULL) {
                printf("Specified NIC doesn't exist or cannot connect to it.\n");
                return EINVAL;
        }

        if (!str_cmp(str, "block")) {
                nic_broadcast_set_mode(sess, NIC_BROADCAST_BLOCKED);
                return EOK;
        }

        if (!str_cmp(str, "accept")) {
                nic_broadcast_set_mode(sess, NIC_BROADCAST_ACCEPTED);
                return EOK;
        }

        printf("Invalid pameter - should be 'block' or 'accept'\n");
        return EINVAL;
}

int main(int argc, char *argv[])
{
        errno_t rc;
        uint32_t index;

        if (argc == 1) {
                rc = nic_list();
                if (rc != EOK)
                        return 1;
        } else if (argc >= 3) {
                rc = str_uint32_t(argv[1], NULL, 10, false, &index);
                if (rc != EOK) {
                        printf(NAME ": Invalid argument.\n");
                        print_syntax();
                        return 1;
                }

                if (!str_cmp(argv[2], "addr"))
                        return nic_set_addr(index, argv[3]);

                if (!str_cmp(argv[2], "speed"))
                        return nic_set_speed(index, argv[3]);

                if (!str_cmp(argv[2], "duplex"))
                        return nic_set_duplex(index, argv[3]);

                if (!str_cmp(argv[2], "auto"))
                        return nic_set_autoneg(index);

                if (!str_cmp(argv[2], "unicast"))
                        return nic_set_rx_unicast(index, argv[3]);

                if (!str_cmp(argv[2], "multicast"))
                        return nic_set_rx_multicast(index, argv[3]);

                if (!str_cmp(argv[2], "broadcast"))
                        return nic_set_rx_broadcast(index, argv[3]);

        } else {
                printf(NAME ": Invalid argument.\n");
                print_syntax();
                return 1;
        }

        return 0;
}

/** @}
 */