mbtk/libmbtk_lib/net/mbtk_dhcp.c

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/time.h>
#include <poll.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <linux/if_ether.h>
#include <linux/if_packet.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/udp.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <time.h>

#include "mbtk_log.h"
#include "mbtk_type.h"
#include "mbtk_ifc.h"
#include "mbtk_dhcp.h"

#define VERBOSE 2
#define STATE_SELECTING  1
#define STATE_REQUESTING 2

#define TIMEOUT_INITIAL   4000
#define TIMEOUT_MAX      32000

static int verbose = 1;
// static char errmsg[2048];

static void *init_dhcp_msg(dhcp_msg *msg, int type, void *hwaddr, uint32_t xid)
{
    uint8_t *x;

    memset(msg, 0, sizeof(dhcp_msg));

    msg->op = OP_BOOTREQUEST;
    msg->htype = HTYPE_ETHER;
    msg->hlen = 6;
    msg->hops = 0;

    msg->flags = htons(FLAGS_BROADCAST);

    msg->xid = xid;

    memcpy(msg->chaddr, hwaddr, 6);

    x = msg->options;

    *x++ = OPT_COOKIE1;
    *x++ = OPT_COOKIE2;
    *x++ = OPT_COOKIE3;
    *x++ = OPT_COOKIE4;

    *x++ = OPT_MESSAGE_TYPE;
    *x++ = 1;
    *x++ = type;

    return x;
}

static int init_dhcp_discover_msg(dhcp_msg *msg, void *hwaddr, uint32_t xid)
{
    uint8_t *x;

    x = init_dhcp_msg(msg, DHCPDISCOVER, hwaddr, xid);

    *x++ = OPT_PARAMETER_LIST;
    *x++ = 4;
    *x++ = OPT_SUBNET_MASK;
    *x++ = OPT_GATEWAY;
    *x++ = OPT_DNS;
    *x++ = OPT_BROADCAST_ADDR;

    *x++ = OPT_END;

    return DHCP_MSG_FIXED_SIZE + (x - msg->options);
}

static int init_dhcp_request_msg(dhcp_msg *msg, void *hwaddr, uint32_t xid,
                                 uint32_t ipaddr, uint32_t serveraddr)
{
    uint8_t *x;

    x = init_dhcp_msg(msg, DHCPREQUEST, hwaddr, xid);

    *x++ = OPT_PARAMETER_LIST;
    *x++ = 4;
    *x++ = OPT_SUBNET_MASK;
    *x++ = OPT_GATEWAY;
    *x++ = OPT_DNS;
    *x++ = OPT_BROADCAST_ADDR;

    *x++ = OPT_REQUESTED_IP;
    *x++ = 4;
    memcpy(x, &ipaddr, 4);
    x +=  4;

    *x++ = OPT_SERVER_ID;
    *x++ = 4;
    memcpy(x, &serveraddr, 4);
    x += 4;

    *x++ = OPT_END;

    return DHCP_MSG_FIXED_SIZE + (x - msg->options);
}


static msecs_t get_msecs(void)
{
    struct timespec ts;

    if (clock_gettime(CLOCK_MONOTONIC, &ts))
    {
        return 0;
    }
    else
    {
        return (((msecs_t) ts.tv_sec) * ((msecs_t) 1000)) +
               (((msecs_t) ts.tv_nsec) / ((msecs_t) 1000000));
    }
}

static int open_raw_socket(const char *ifname __attribute__((unused)), uint8_t *hwaddr, int if_index)
{
    int s;
    struct sockaddr_ll bindaddr;

    if((s = socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP))) < 0)
    {
        LOGE("socket(PF_PACKET)");
        return -1;
    }

    memset(&bindaddr, 0, sizeof(bindaddr));
    bindaddr.sll_family = AF_PACKET;
    bindaddr.sll_protocol = htons(ETH_P_IP);
    bindaddr.sll_halen = ETH_ALEN;
    memcpy(bindaddr.sll_addr, hwaddr, ETH_ALEN);
    bindaddr.sll_ifindex = if_index;

    if (bind(s, (struct sockaddr *)&bindaddr, sizeof(bindaddr)) < 0)
    {
        LOGE("Cannot bind raw socket to interface");
        return -1;
    }

    return s;
}

static uint32_t checksum(void *buffer, unsigned int count, uint32_t startsum)
{
    uint16_t *up = (uint16_t *)buffer;
    uint32_t sum = startsum;
    uint32_t upper16;

    while (count > 1)
    {
        sum += *up++;
        count -= 2;
    }
    if (count > 0)
    {
        sum += (uint16_t) *(uint8_t *)up;
    }
    while ((upper16 = (sum >> 16)) != 0)
    {
        sum = (sum & 0xffff) + upper16;
    }
    return sum;
}

static uint32_t finish_sum(uint32_t sum)
{
    return ~sum & 0xffff;
}

static int send_packet(int s, int if_index, dhcp_msg *msg, int size,
                       uint32_t saddr, uint32_t daddr, uint32_t sport, uint32_t dport)
{
    struct iphdr ip;
    struct udphdr udp;
    struct iovec iov[3];
    uint32_t udpsum;
    uint16_t temp;
    struct msghdr msghdr;
    struct sockaddr_ll destaddr;

    ip.version = IPVERSION;
    ip.ihl = sizeof(ip) >> 2;
    ip.tos = 0;
    ip.tot_len = htons(sizeof(ip) + sizeof(udp) + size);
    ip.id = 0;
    ip.frag_off = 0;
    ip.ttl = IPDEFTTL;
    ip.protocol = IPPROTO_UDP;
    ip.check = 0;
    ip.saddr = saddr;
    ip.daddr = daddr;
    ip.check = finish_sum(checksum(&ip, sizeof(ip), 0));

    udp.source = htons(sport);
    udp.dest = htons(dport);
    udp.len = htons(sizeof(udp) + size);
    udp.check = 0;

    /* Calculate checksum for pseudo header */
    udpsum = checksum(&ip.saddr, sizeof(ip.saddr), 0);
    udpsum = checksum(&ip.daddr, sizeof(ip.daddr), udpsum);
    temp = htons(IPPROTO_UDP);
    udpsum = checksum(&temp, sizeof(temp), udpsum);
    temp = udp.len;
    udpsum = checksum(&temp, sizeof(temp), udpsum);

    /* Add in the checksum for the udp header */
    udpsum = checksum(&udp, sizeof(udp), udpsum);

    /* Add in the checksum for the data */
    udpsum = checksum(msg, size, udpsum);
    udp.check = finish_sum(udpsum);

    iov[0].iov_base = (char *)&ip;
    iov[0].iov_len = sizeof(ip);
    iov[1].iov_base = (char *)&udp;
    iov[1].iov_len = sizeof(udp);
    iov[2].iov_base = (char *)msg;
    iov[2].iov_len = size;
    memset(&destaddr, 0, sizeof(destaddr));
    destaddr.sll_family = AF_PACKET;
    destaddr.sll_protocol = htons(ETH_P_IP);
    destaddr.sll_ifindex = if_index;
    destaddr.sll_halen = ETH_ALEN;
    memcpy(destaddr.sll_addr, "\xff\xff\xff\xff\xff\xff", ETH_ALEN);

    msghdr.msg_name = &destaddr;
    msghdr.msg_namelen = sizeof(destaddr);
    msghdr.msg_iov = iov;
    msghdr.msg_iovlen = sizeof(iov) / sizeof(struct iovec);
    msghdr.msg_flags = 0;
    msghdr.msg_control = 0;
    msghdr.msg_controllen = 0;
    return sendmsg(s, &msghdr, 0);
}

static int receive_packet(int s, dhcp_msg *msg)
{
    int nread;
    int is_valid;
    struct dhcp_packet
    {
        struct iphdr ip;
        struct udphdr udp;
        dhcp_msg dhcp;
    } packet;
    int dhcp_size;
    uint32_t sum;
    uint16_t temp;
    uint32_t saddr, daddr;

    nread = read(s, &packet, sizeof(packet));
    if (nread < 0)
    {
        return -1;
    }
    /*
     * The raw packet interface gives us all packets received by the
     * network interface. We need to filter out all packets that are
     * not meant for us.
     */
    is_valid = 0;
    if (nread < (int)(sizeof(struct iphdr) + sizeof(struct udphdr)))
    {
#if VERBOSE
        LOGD("Packet is too small (%d) to be a UDP datagram", nread);
#endif
    }
    else if (packet.ip.version != IPVERSION || packet.ip.ihl != (sizeof(packet.ip) >> 2))
    {
#if VERBOSE
        LOGD("Not a valid IP packet");
#endif
    }
    else if (nread < ntohs(packet.ip.tot_len))
    {
#if VERBOSE
        LOGD("Packet was truncated (read %d, needed %d)", nread, ntohs(packet.ip.tot_len));
#endif
    }
    else if (packet.ip.protocol != IPPROTO_UDP)
    {
#if VERBOSE
        LOGD("IP protocol (%d) is not UDP", packet.ip.protocol);
#endif
    }
    else if (packet.udp.dest != htons(PORT_BOOTP_CLIENT))
    {
#if VERBOSE
        LOGD("UDP dest port (%d) is not DHCP client", ntohs(packet.udp.dest));
#endif
    }
    else
    {
        is_valid = 1;
    }

    if (!is_valid)
    {
        return -1;
    }

    /* Seems like it's probably a valid DHCP packet */
    /* validate IP header checksum */
    sum = finish_sum(checksum(&packet.ip, sizeof(packet.ip), 0));
    if (sum != 0)
    {
        LOGW("IP header checksum failure (0x%x)", packet.ip.check);
        return -1;
    }
    /*
     * Validate the UDP checksum.
     * Since we don't need the IP header anymore, we "borrow" it
     * to construct the pseudo header used in the checksum calculation.
     */
    dhcp_size = ntohs(packet.udp.len) - sizeof(packet.udp);
    /*
     * check validity of dhcp_size.
     * 1) cannot be negative or zero.
     * 2) src buffer contains enough bytes to copy
     * 3) cannot exceed destination buffer
     */
    if ((dhcp_size <= 0) ||
        ((int)(nread - sizeof(struct iphdr) - sizeof(struct udphdr)) < dhcp_size) ||
        ((int)sizeof(dhcp_msg) < dhcp_size))
    {
#if VERBOSE
        LOGD("Malformed Packet");
#endif
        return -1;
    }
    saddr = packet.ip.saddr;
    daddr = packet.ip.daddr;
    nread = ntohs(packet.ip.tot_len);
    memset(&packet.ip, 0, sizeof(packet.ip));
    packet.ip.saddr = saddr;
    packet.ip.daddr = daddr;
    packet.ip.protocol = IPPROTO_UDP;
    packet.ip.tot_len = packet.udp.len;
    temp = packet.udp.check;
    packet.udp.check = 0;
    sum = finish_sum(checksum(&packet, nread, 0));
    packet.udp.check = temp;
    if (!sum)
        sum = finish_sum(sum);
    if (temp != sum)
    {
        LOGW("UDP header checksum failure (0x%x should be 0x%x)", sum, temp);
        return -1;
    }
    memcpy(msg, &packet.dhcp, dhcp_size);
    return dhcp_size;
}

static void hex2str(char *buf, size_t buf_size, const unsigned char *array, int len)
{
    int i;
    char *cp = buf;
    char *buf_end = buf + buf_size;
    for (i = 0; i < len; i++)
    {
        cp += snprintf(cp, buf_end - cp, " %02x ", array[i]);
    }
}

static const char *ipaddr(in_addr_t addr)
{
    struct in_addr in_addr;

    in_addr.s_addr = addr;
    return inet_ntoa(in_addr);
}

static const char *dhcp_type_to_name(uint32_t type)
{
    switch(type)
    {
        case DHCPDISCOVER:
            return "discover";
        case DHCPOFFER:
            return "offer";
        case DHCPREQUEST:
            return "request";
        case DHCPDECLINE:
            return "decline";
        case DHCPACK:
            return "ack";
        case DHCPNAK:
            return "nak";
        case DHCPRELEASE:
            return "release";
        case DHCPINFORM:
            return "inform";
        default:
            return "???";
    }
}

static void dump_dhcp_msg(dhcp_msg *msg, int len)
{
    unsigned char *x;
    unsigned int n,c;
    int optsz;
    const char *name;
    char buf[2048];

    LOGD("===== DHCP message:");
    if (len < DHCP_MSG_FIXED_SIZE)
    {
        LOGD("Invalid length %d, should be %d", len, DHCP_MSG_FIXED_SIZE);
        return;
    }

    len -= DHCP_MSG_FIXED_SIZE;

    if (msg->op == OP_BOOTREQUEST)
        name = "BOOTREQUEST";
    else if (msg->op == OP_BOOTREPLY)
        name = "BOOTREPLY";
    else
        name = "????";
    LOGD("op = %s (%d), htype = %d, hlen = %d, hops = %d",
         name, msg->op, msg->htype, msg->hlen, msg->hops);
    LOGD("xid = 0x%08x secs = %d, flags = 0x%04x optlen = %d",
         ntohl(msg->xid), ntohs(msg->secs), ntohs(msg->flags), len);
    LOGD("ciaddr = %s", ipaddr(msg->ciaddr));
    LOGD("yiaddr = %s", ipaddr(msg->yiaddr));
    LOGD("siaddr = %s", ipaddr(msg->siaddr));
    LOGD("giaddr = %s", ipaddr(msg->giaddr));

    c = msg->hlen > 16 ? 16 : msg->hlen;
    hex2str(buf, sizeof(buf), msg->chaddr, c);
    LOGD("chaddr = {%s}", buf);

    for (n = 0; n < 64; n++)
    {
        unsigned char x = msg->sname[n];
        if ((x < ' ') || (x > 127))
        {
            if (x == 0) break;
            msg->sname[n] = '.';
        }
    }
    msg->sname[63] = 0;

    for (n = 0; n < 128; n++)
    {
        unsigned char x = msg->file[n];
        if ((x < ' ') || (x > 127))
        {
            if (x == 0) break;
            msg->file[n] = '.';
        }
    }
    msg->file[127] = 0;

    LOGD("sname = '%s'", msg->sname);
    LOGD("file = '%s'", msg->file);

    if (len < 4) return;
    len -= 4;
    x = msg->options + 4;

    while (len > 2)
    {
        if (*x == 0)
        {
            x++;
            len--;
            continue;
        }
        if (*x == OPT_END)
        {
            break;
        }
        len -= 2;
        optsz = x[1];
        if (optsz > len) break;
        if (x[0] == OPT_DOMAIN_NAME || x[0] == OPT_MESSAGE)
        {
            if ((unsigned int)optsz < sizeof(buf) - 1)
            {
                n = optsz;
            }
            else
            {
                n = sizeof(buf) - 1;
            }
            memcpy(buf, &x[2], n);
            buf[n] = '\0';
        }
        else
        {
            hex2str(buf, sizeof(buf), &x[2], optsz);
        }
        if (x[0] == OPT_MESSAGE_TYPE)
            name = dhcp_type_to_name(x[2]);
        else
            name = NULL;
        LOGD("op %d len %d {%s} %s", x[0], optsz, buf, name == NULL ? "" : name);
        len -= optsz;
        x = x + optsz + 2;
    }
}

static int send_message(int sock, int if_index, dhcp_msg  *msg, int size)
{
#if VERBOSE > 1
    dump_dhcp_msg(msg, size);
#endif
    return send_packet(sock, if_index, msg, size, INADDR_ANY, INADDR_BROADCAST,
                       PORT_BOOTP_CLIENT, PORT_BOOTP_SERVER);
}

// static dhcp_info last_good_info;
static int dhcp_configure(const char *ifname, dhcp_info *info)
{
    //last_good_info = *info;
    return mbtk_ifc_configure1(ifname, info->ipaddr, info->prefixLength, info->gateway, 0);
}

static int is_valid_reply(dhcp_msg *msg, dhcp_msg *reply, int sz)
{
    if (sz < DHCP_MSG_FIXED_SIZE)
    {
        if (verbose) LOGD("Wrong size %d != %d\n", sz, DHCP_MSG_FIXED_SIZE);
        return 0;
    }
    if (reply->op != OP_BOOTREPLY)
    {
        if (verbose) LOGD("Wrong Op %d != %d\n", reply->op, OP_BOOTREPLY);
        return 0;
    }
    if (reply->xid != msg->xid)
    {
        if (verbose) LOGD("Wrong Xid 0x%x != 0x%x\n", ntohl(reply->xid),
                              ntohl(msg->xid));
        return 0;
    }
    if (reply->htype != msg->htype)
    {
        if (verbose) LOGD("Wrong Htype %d != %d\n", reply->htype, msg->htype);
        return 0;
    }
    if (reply->hlen != msg->hlen)
    {
        if (verbose) LOGD("Wrong Hlen %d != %d\n", reply->hlen, msg->hlen);
        return 0;
    }
    if (memcmp(msg->chaddr, reply->chaddr, msg->hlen))
    {
        if (verbose) LOGD("Wrong chaddr %x != %x\n", *(reply->chaddr),*(msg->chaddr));
        return 0;
    }
    return 1;
}

int ipv4NetmaskToPrefixLength(in_addr_t mask)
{
    int prefixLength = 0;
    uint32_t m = (uint32_t)ntohl(mask);
    while (m & 0x80000000)
    {
        prefixLength++;
        m = m << 1;
    }
    return prefixLength;
}

static int decode_dhcp_msg(dhcp_msg *msg, int len, dhcp_info *info)
{
    uint8_t *x;
    unsigned int opt;
    int optlen;

    memset(info, 0, sizeof(dhcp_info));
    if (len < (DHCP_MSG_FIXED_SIZE + 4)) return -1;

    len -= (DHCP_MSG_FIXED_SIZE + 4);

    if (msg->options[0] != OPT_COOKIE1) return -1;
    if (msg->options[1] != OPT_COOKIE2) return -1;
    if (msg->options[2] != OPT_COOKIE3) return -1;
    if (msg->options[3] != OPT_COOKIE4) return -1;

    x = msg->options + 4;

    while (len > 2)
    {
        opt = *x++;
        if (opt == OPT_PAD)
        {
            len--;
            continue;
        }
        if (opt == OPT_END)
        {
            break;
        }
        optlen = *x++;
        len -= 2;
        if (optlen > len)
        {
            break;
        }
        switch(opt)
        {
            case OPT_SUBNET_MASK:
                if (optlen >= 4)
                {
                    in_addr_t mask;
                    memcpy(&mask, x, 4);
                    info->prefixLength = ipv4NetmaskToPrefixLength(mask);
                }
                break;
            case OPT_GATEWAY:
                if (optlen >= 4) memcpy(&info->gateway, x, 4);
                break;
            case OPT_DNS:
                if (optlen >= 4) memcpy(&info->dns1, x + 0, 4);
                if (optlen >= 8) memcpy(&info->dns2, x + 4, 4);
                break;
            case OPT_LEASE_TIME:
                if (optlen >= 4)
                {
                    memcpy(&info->lease, x, 4);
                    info->lease = ntohl(info->lease);
                }
                break;
            case OPT_SERVER_ID:
                if (optlen >= 4) memcpy(&info->serveraddr, x, 4);
                break;
            case OPT_MESSAGE_TYPE:
                info->type = *x;
                break;
            default:
                break;
        }
        x += optlen;
        len -= optlen;
    }

    info->ipaddr = msg->yiaddr;

    return 0;
}

void dump_dhcp_info(dhcp_info *info)
{
    char addr[20], gway[20];
    LOGD("--- dhcp %s (%d) ---",
    dhcp_type_to_name(info->type), info->type);
    strcpy(addr, ipaddr(info->ipaddr));
    strcpy(gway, ipaddr(info->gateway));
    LOGD("ip %s gw %s prefixLength %d", addr, gway, info->prefixLength);
    if (info->dns1) LOGD("dns1: %s", ipaddr(info->dns1));
    if (info->dns2) LOGD("dns2: %s", ipaddr(info->dns2));
    LOGD("server %s, lease %d seconds",
         ipaddr(info->serveraddr), info->lease);
}

static int dhcp_init_ifc(const char *ifname)
{
    dhcp_msg discover_msg;
    dhcp_msg request_msg;
    dhcp_msg reply;
    dhcp_msg *msg;
    dhcp_info info;
    int s, r, size;
    int valid_reply;
    uint32_t xid;
    unsigned char hwaddr[6];
    struct pollfd pfd;
    unsigned int state;
    unsigned int timeout;
    int if_index;

    xid = (uint32_t) get_msecs();
    if (mbtk_ifc_get_hwaddr(ifname, hwaddr))
    {
        LOGE("cannot obtain interface address");
        return -1;
    }
    if (mbtk_ifc_get_ifindex(ifname, &if_index))
    {
        LOGE("cannot obtain interface index");
        return -1;
    }

    s = open_raw_socket(ifname, hwaddr, if_index);

    timeout = TIMEOUT_INITIAL;
    state = STATE_SELECTING;
    info.type = 0;
    goto transmit;

    for (;;)
    {
        pfd.fd = s;
        pfd.events = POLLIN;
        pfd.revents = 0;
        r = poll(&pfd, 1, timeout);

        if (r == 0)
        {
#if VERBOSE
            LOGE("TIMEOUT");
#endif
            if (timeout >= TIMEOUT_MAX)
            {
                LOGE("timed out");
                if ( info.type == DHCPOFFER )
                {
                    LOGE("no acknowledgement from DHCP server\nconfiguring %s with offered parameters", ifname);
                    return dhcp_configure(ifname, &info);
                }
                errno = ETIME;
                close(s);
                return -1;
            }
            timeout = timeout * 2;

        transmit:
            size = 0;
            msg = NULL;
            switch(state)
            {
                case STATE_SELECTING:
                    msg = &discover_msg;
                    size = init_dhcp_discover_msg(msg, hwaddr, xid);
                    break;
                case STATE_REQUESTING:
                    msg = &request_msg;
                    size = init_dhcp_request_msg(msg, hwaddr, xid, info.ipaddr, info.serveraddr);
                    break;
                default:
                    r = 0;
            }
            if (size != 0)
            {
                r = send_message(s, if_index, msg, size);
                if (r < 0)
                {
                    LOGE("error sending dhcp msg: %s\n", strerror(errno));
                }
            }
            continue;
        }

        if (r < 0)
        {
            if ((errno == EAGAIN) || (errno == EINTR))
            {
                continue;
            }
            LOGE("poll failed");
            return -1;
        }

        errno = 0;
        r = receive_packet(s, &reply);
        if (r < 0)
        {
            if (errno != 0)
            {
                LOGD("receive_packet failed (%d): %s", r, strerror(errno));
                if (errno == ENETDOWN || errno == ENXIO)
                {
                    return -1;
                }
            }
            continue;
        }

#if VERBOSE > 1
        dump_dhcp_msg(&reply, r);
#endif
        decode_dhcp_msg(&reply, r, &info);

        if (state == STATE_SELECTING)
        {
            valid_reply = is_valid_reply(&discover_msg, &reply, r);
        }
        else
        {
            valid_reply = is_valid_reply(&request_msg, &reply, r);
        }
        if (!valid_reply)
        {
            LOGE("invalid reply");
            continue;
        }

        if (verbose)
            dump_dhcp_info(&info);

        switch(state)
        {
            case STATE_SELECTING:
                if (info.type == DHCPOFFER)
                {
                    state = STATE_REQUESTING;
                    timeout = TIMEOUT_INITIAL;
                    xid++;
                    goto transmit;
                }
                break;
            case STATE_REQUESTING:
                if (info.type == DHCPACK)
                {
                    LOGE("configuring %s", ifname);
                    close(s);
                    return dhcp_configure(ifname, &info);
                }
                else if (info.type == DHCPNAK)
                {
                    LOGE("configuration request denied");
                    close(s);
                    return -1;
                }
                else
                {
                    LOGE("ignoring %s message in state %d",
                         dhcp_type_to_name(info.type), state);
                }
                break;
        }
    }
    close(s);
    return 0;
}


int mbtk_do_dhcp(const char *name)
{
    int ret = 0;
    if(mbtk_ifc_open())
    {
        LOGE("mbtk_ifc_open() fail.");
        ret = -1;
        goto return_result;
    }

    if (mbtk_ifc_set_addr(name, 0, 0))
    {
        LOGE("failed to set ip addr for %s to 0.0.0.0: %s", name, strerror(errno));
        ret = -1;
        goto return_result;
    }

    if (mbtk_ifc_up(name))
    {
        LOGE("failed to bring up interface %s: %s", name, strerror(errno));
        ret = -1;
        goto return_result;
    }

    if(dhcp_init_ifc(name))
    {
        LOGE("dhcp_init_ifc() fail.");
        ret = -1;
        goto return_result;
    }

return_result:

    mbtk_ifc_close();

    return ret;
}