wpa_supplicant与kernel交互

static int select_driver(struct wpa_supplicant *wpa_s, int i)

{

    struct wpa_global *global = wpa_s->global;

if (wpa_drivers[i]->global_init && global->drv_priv[i] == NULL) {

    //调用global_init方法，这与driver选择wext调用的流程不同了

        global->drv_priv[i] = wpa_drivers[i]->global_init();

        if (global->drv_priv[i] == NULL) {

            wpa_printf(MSG_ERROR, "Failed to initialize driver "

                   "'%s'", wpa_drivers[i]->name);

            return -;

        }

    }

// 根据name进行匹配，并最后保存到wpa_supplicant->dirver中

    wpa_s->driver = wpa_drivers[i];

    wpa_s->global_drv_priv = global->drv_priv[i];

    return ;

}

const struct wpa_driver_ops wpa_driver_nl80211_ops = {

    .name = "nl80211",

    .desc = "Linux nl80211/cfg80211",

    .get_bssid = wpa_driver_nl80211_get_bssid,

    .get_ssid = wpa_driver_nl80211_get_ssid,

    .set_key = wpa_driver_nl80211_set_key,

    .scan2 = wpa_driver_nl80211_scan,

    .sched_scan = wpa_driver_nl80211_sched_scan,

    .stop_sched_scan = wpa_driver_nl80211_stop_sched_scan,

    .get_scan_results2 = wpa_driver_nl80211_get_scan_results,

    .deauthenticate = wpa_driver_nl80211_deauthenticate,

    .disassociate = wpa_driver_nl80211_disassociate,

    .authenticate = wpa_driver_nl80211_authenticate,

    .associate = wpa_driver_nl80211_associate,

    .global_init = nl80211_global_init,

    .global_deinit = nl80211_global_deinit,

    .init2 = wpa_driver_nl80211_init,

    .deinit = wpa_driver_nl80211_deinit,

    .get_capa = wpa_driver_nl80211_get_capa,

    .set_operstate = wpa_driver_nl80211_set_operstate,

    .set_supp_port = wpa_driver_nl80211_set_supp_port,

    .set_country = wpa_driver_nl80211_set_country,

    .set_ap = wpa_driver_nl80211_set_ap,

    .if_add = wpa_driver_nl80211_if_add,

    .if_remove = wpa_driver_nl80211_if_remove,

    .send_mlme = wpa_driver_nl80211_send_mlme,

    .get_hw_feature_data = wpa_driver_nl80211_get_hw_feature_data,

    .sta_add = wpa_driver_nl80211_sta_add,

    .sta_remove = wpa_driver_nl80211_sta_remove,

    .hapd_send_eapol = wpa_driver_nl80211_hapd_send_eapol,

#ifdef ANDROID_QCOM_PATCH

    .hapd_set_countermeasures = wpa_driver_nl80211_set_countermeasures,

#endif

    .sta_set_flags = wpa_driver_nl80211_sta_set_flags,

#ifdef HOSTAPD

    .hapd_init = i802_init,

    .hapd_deinit = i802_deinit,

    .set_wds_sta = i802_set_wds_sta,

#endif /* HOSTAPD */

#if defined(HOSTAPD) || defined(CONFIG_AP)

    .get_seqnum = i802_get_seqnum,

    .flush = i802_flush,

    .read_sta_data = i802_read_sta_data,

    .get_inact_sec = i802_get_inact_sec,

    .sta_clear_stats = i802_sta_clear_stats,

    .set_rts = i802_set_rts,

    .set_frag = i802_set_frag,

    .set_tx_queue_params = i802_set_tx_queue_params,

    .set_sta_vlan = i802_set_sta_vlan,

    .sta_deauth = i802_sta_deauth,

    .sta_disassoc = i802_sta_disassoc,

#endif /* HOSTAPD || CONFIG_AP */

    .set_freq = i802_set_freq,

    .send_action = wpa_driver_nl80211_send_action,

    .send_action_cancel_wait = wpa_driver_nl80211_send_action_cancel_wait,

    .remain_on_channel = wpa_driver_nl80211_remain_on_channel,

    .cancel_remain_on_channel =

    wpa_driver_nl80211_cancel_remain_on_channel,

    .probe_req_report = wpa_driver_nl80211_probe_req_report,

    .deinit_ap = wpa_driver_nl80211_deinit_ap,

    .resume = wpa_driver_nl80211_resume,

    .send_ft_action = nl80211_send_ft_action,

    .signal_monitor = nl80211_signal_monitor,

    .signal_poll = nl80211_signal_poll,

    .send_frame = nl80211_send_frame,

    .shared_freq = wpa_driver_nl80211_shared_freq,

    .set_param = nl80211_set_param,

    .get_radio_name = nl80211_get_radio_name,

    .add_pmkid = nl80211_add_pmkid,

    .remove_pmkid = nl80211_remove_pmkid,

    .flush_pmkid = nl80211_flush_pmkid,

    .set_rekey_info = nl80211_set_rekey_info,

    .poll_client = nl80211_poll_client,

    .set_p2p_powersave = nl80211_set_p2p_powersave,

#ifdef CONFIG_TDLS

    .send_tdls_mgmt = nl80211_send_tdls_mgmt,

    .tdls_oper = nl80211_tdls_oper,

#endif /* CONFIG_TDLS */

#ifdef ANDROID_P2P

    .set_noa = wpa_driver_set_p2p_noa,

#endif

#ifdef ANDROID

    .driver_cmd = wpa_driver_nl80211_driver_cmd, //处理DRIVER开头的命令

#endif

};

wpa_supplicant_ctrl_iface_process-> (根据命令字符串调用对应的函数)

wpa_supplicant_driver_cmd->

wpa_drv_driver_cmd->

wpa_s->driver->driver_cmd->

wpa_driver_nl80211_driver_cmd -> (User)

...

cfg80211...

static const iw_handler cfg80211_handlers[] = {

    [IW_IOCTL_IDX(SIOCGIWNAME)] = (iw_handler) cfg80211_wext_giwname,

    [IW_IOCTL_IDX(SIOCSIWFREQ)] = (iw_handler) cfg80211_wext_siwfreq,

    [IW_IOCTL_IDX(SIOCGIWFREQ)] = (iw_handler) cfg80211_wext_giwfreq,

    [IW_IOCTL_IDX(SIOCSIWMODE)] = (iw_handler) cfg80211_wext_siwmode,

    [IW_IOCTL_IDX(SIOCGIWMODE)] = (iw_handler) cfg80211_wext_giwmode,

    [IW_IOCTL_IDX(SIOCGIWRANGE)]    = (iw_handler) cfg80211_wext_giwrange,

    [IW_IOCTL_IDX(SIOCSIWAP)]   = (iw_handler) cfg80211_wext_siwap,

    [IW_IOCTL_IDX(SIOCGIWAP)]   = (iw_handler) cfg80211_wext_giwap,

    [IW_IOCTL_IDX(SIOCSIWMLME)] = (iw_handler) cfg80211_wext_siwmlme,

    [IW_IOCTL_IDX(SIOCSIWSCAN)] = (iw_handler) cfg80211_wext_siwscan,

    [IW_IOCTL_IDX(SIOCGIWSCAN)] = (iw_handler) cfg80211_wext_giwscan,

    [IW_IOCTL_IDX(SIOCSIWESSID)]    = (iw_handler) cfg80211_wext_siwessid,

    [IW_IOCTL_IDX(SIOCGIWESSID)]    = (iw_handler) cfg80211_wext_giwessid,

    [IW_IOCTL_IDX(SIOCSIWRATE)] = (iw_handler) cfg80211_wext_siwrate,

    [IW_IOCTL_IDX(SIOCGIWRATE)] = (iw_handler) cfg80211_wext_giwrate,

    [IW_IOCTL_IDX(SIOCSIWRTS)]  = (iw_handler) cfg80211_wext_siwrts,

    [IW_IOCTL_IDX(SIOCGIWRTS)]  = (iw_handler) cfg80211_wext_giwrts,

    [IW_IOCTL_IDX(SIOCSIWFRAG)] = (iw_handler) cfg80211_wext_siwfrag,

    [IW_IOCTL_IDX(SIOCGIWFRAG)] = (iw_handler) cfg80211_wext_giwfrag,

    [IW_IOCTL_IDX(SIOCSIWTXPOW)]    = (iw_handler) cfg80211_wext_siwtxpower,

    [IW_IOCTL_IDX(SIOCGIWTXPOW)]    = (iw_handler) cfg80211_wext_giwtxpower,

    [IW_IOCTL_IDX(SIOCSIWRETRY)]    = (iw_handler) cfg80211_wext_siwretry,

    [IW_IOCTL_IDX(SIOCGIWRETRY)]    = (iw_handler) cfg80211_wext_giwretry,

    [IW_IOCTL_IDX(SIOCSIWENCODE)]   = (iw_handler) cfg80211_wext_siwencode,

    [IW_IOCTL_IDX(SIOCGIWENCODE)]   = (iw_handler) cfg80211_wext_giwencode,

    [IW_IOCTL_IDX(SIOCSIWPOWER)]    = (iw_handler) cfg80211_wext_siwpower,

    [IW_IOCTL_IDX(SIOCGIWPOWER)]    = (iw_handler) cfg80211_wext_giwpower,

    [IW_IOCTL_IDX(SIOCSIWGENIE)]    = (iw_handler) cfg80211_wext_siwgenie,

    [IW_IOCTL_IDX(SIOCSIWAUTH)] = (iw_handler) cfg80211_wext_siwauth,

    [IW_IOCTL_IDX(SIOCGIWAUTH)] = (iw_handler) cfg80211_wext_giwauth,

    [IW_IOCTL_IDX(SIOCSIWENCODEEXT)]= (iw_handler) cfg80211_wext_siwencodeext,

    [IW_IOCTL_IDX(SIOCSIWPMKSA)]    = (iw_handler) cfg80211_wext_siwpmksa,

};

const struct iw_handler_def cfg80211_wext_handler = {

    .num_standard       = ARRAY_SIZE(cfg80211_handlers),

    .standard       = cfg80211_handlers,

    .get_wireless_stats = cfg80211_wireless_stats,

};

static void * nl80211_global_init(void)

{

    struct nl80211_global *global;

    struct netlink_config *cfg;

    global = os_zalloc(sizeof(*global));

    if (global == NULL)

        return NULL;

    global->ioctl_sock = -;

    dl_list_init(&global->interfaces);

    global->if_add_ifindex = -;

    cfg = os_zalloc(sizeof(*cfg));

    if (cfg == NULL)

        goto err;

    cfg->ctx = global;

    cfg->newlink_cb = wpa_driver_nl80211_event_rtm_newlink;

    cfg->dellink_cb = wpa_driver_nl80211_event_rtm_dellink;

    global->netlink = netlink_init(cfg); //初始化netlink,并注册事件接收函数 

    if (global->netlink == NULL) {

        os_free(cfg);

        goto err;

    }  

    if (wpa_driver_nl80211_init_nl_global(global) < )

        goto err;

// 此global->ioctl_sock用作为ioctl命令的fd

    global->ioctl_sock = socket(PF_INET, SOCK_DGRAM, );

    if (global->ioctl_sock < ) {

        perror("socket(PF_INET,SOCK_DGRAM)");

        goto err;

    }  

    return global;

err:

    nl80211_global_deinit(global);

    return NULL;

}

(a)

// 初始化netlink,并注册事件接收函数

global->netlink = netlink_init(cfg); 

(b)

// 此global->ioctl_sock用作为ioctl命令的fd

global->ioctl_sock = socket(PF_INET, SOCK_DGRAM, );

netlink->sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

......

eloop_register_read_sock(netlink->sock, netlink_receive, netlink,NULL); 

if (wpa_supplicant_set_driver(wpa_s, driver) < )

    return -;

wpa_s->drv_priv = wpa_drv_init(wpa_s, wpa_s->ifname);

/*

 *  Socket files have a set of 'special' operations as well as the generic file ones. These don't appear in the operation structures but are done directly via the socketcall() multiplexor.

 */

static const struct file_operations socket_file_ops = {

    .owner =    THIS_MODULE,

    .llseek =   no_llseek,

    .aio_read = sock_aio_read,

    .aio_write =    sock_aio_write,

    .poll =     sock_poll,

    .unlocked_ioctl = sock_ioctl, // 这个就是被执行的ioctl 

#ifdef CONFIG_COMPAT

    .compat_ioctl = compat_sock_ioctl,

#endif

    .mmap =     sock_mmap,

    .open =     sock_no_open,   /* special open code to disallow open via /proc */

    .release =  sock_close,

    .fasync =   sock_fasync,

    .sendpage = sock_sendpage,

    .splice_write = generic_splice_sendpage,

    .splice_read =  sock_splice_read,

};

sock_ioctl-> (kernel/net/socket.c)

  dev_ioctl-> (kernel/net/core/dev.c)

    下面的方法都在/net/wireless/wext-core.c中

    wext_handle_ioctl-> (把执行结果从kernel态copy到用户态)

      wext_ioctl_dispatch->(参数包括cmd/ioctl_standard_call/ioctl_private_call)

        wireless_process_ioctl->

          get_handler->  (根据cmd来判断调用standard或是private，即ioctl_standard_call或是ioctl_private_call方法)

      ioctl_standard_call (执行cmd指定的iw_handler<cfg80211_handlers中定义的>，并返回结果)

 /*

  *    With an ioctl, arg may well be a user mode pointer, but we don't know

  *    what to do with it - that's up to the protocol still.

  */

 static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)

 {

     struct socket *sock;

     struct sock *sk;

     void __user *argp = (void __user *)arg;

     int pid, err;

     struct net *net;

     sock = file->private_data;

     sk = sock->sk;

     net = sock_net(sk);

     if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + )) {

         err = dev_ioctl(net, cmd, argp);

     } else

 #ifdef CONFIG_WEXT_CORE

     if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {

         err = dev_ioctl(net, cmd, argp);

     } else

 #endif

         switch (cmd) {

         case FIOSETOWN:

         case SIOCSPGRP:

             err = -EFAULT;

             if (get_user(pid, (int __user *)argp))

                 break;

             err = f_setown(sock->file, pid, );

             break;

         case FIOGETOWN:

         case SIOCGPGRP:

             err = put_user(f_getown(sock->file),

                        (int __user *)argp);

             break;

         case SIOCGIFBR:

         case SIOCSIFBR:

         case SIOCBRADDBR:

         case SIOCBRDELBR:

             err = -ENOPKG;

             if (!br_ioctl_hook)

                 request_module("bridge");

             mutex_lock(&br_ioctl_mutex);

             if (br_ioctl_hook)

                 err = br_ioctl_hook(net, cmd, argp);

             mutex_unlock(&br_ioctl_mutex);

             break;

         case SIOCGIFVLAN:

         case SIOCSIFVLAN:

             err = -ENOPKG;

             if (!vlan_ioctl_hook)

                 request_module("8021q");

             mutex_lock(&vlan_ioctl_mutex);

             if (vlan_ioctl_hook)

                 err = vlan_ioctl_hook(net, argp);

             mutex_unlock(&vlan_ioctl_mutex);

             break;

         case SIOCADDDLCI:

         case SIOCDELDLCI:

             err = -ENOPKG;

             if (!dlci_ioctl_hook)

                 request_module("dlci");

             mutex_lock(&dlci_ioctl_mutex);

             if (dlci_ioctl_hook)

                 err = dlci_ioctl_hook(cmd, argp);

             mutex_unlock(&dlci_ioctl_mutex);

             break;

         default:

             err = sock_do_ioctl(net, sock, cmd, arg);

             break;

         }

     return err;

 }

sock_ioctl

 /**

  *    dev_ioctl    -    network device ioctl

  *    @net: the applicable net namespace

  *    @cmd: command to issue

  *    @arg: pointer to a struct ifreq in user space

  *

  *    Issue ioctl functions to devices. This is normally called by the

  *    user space syscall interfaces but can sometimes be useful for

  *    other purposes. The return value is the return from the syscall if

  *    positive or a negative errno code on error.

  */

 int dev_ioctl(struct net *net, unsigned int cmd, void __user *arg)

 {

     struct ifreq ifr;

     int ret;

     char *colon;

     /* One special case: SIOCGIFCONF takes ifconf argument

        and requires shared lock, because it sleeps writing

        to user space.

      */

     if (cmd == SIOCGIFCONF) {

         rtnl_lock();

         ret = dev_ifconf(net, (char __user *) arg);

         rtnl_unlock();

         return ret;

     }

     if (cmd == SIOCGIFNAME)

         return dev_ifname(net, (struct ifreq __user *)arg);

     if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))

         return -EFAULT;

     ifr.ifr_name[IFNAMSIZ-] = ;

     colon = strchr(ifr.ifr_name, ':');

     if (colon)

         *colon = ;

     /*

      *    See which interface the caller is talking about.

      */

     switch (cmd) {

     /*

      *    These ioctl calls:

      *    - can be done by all.

      *    - atomic and do not require locking.

      *    - return a value

      */

     case SIOCGIFFLAGS:

     case SIOCGIFMETRIC:

     case SIOCGIFMTU:

     case SIOCGIFHWADDR:

     case SIOCGIFSLAVE:

     case SIOCGIFMAP:

     case SIOCGIFINDEX:

     case SIOCGIFTXQLEN:

         dev_load(net, ifr.ifr_name);

         rcu_read_lock();

         ret = dev_ifsioc_locked(net, &ifr, cmd);

         rcu_read_unlock();

         if (!ret) {

             if (colon)

                 *colon = ':';

             if (copy_to_user(arg, &ifr,

                      sizeof(struct ifreq)))

                 ret = -EFAULT;

         }

         return ret;

     case SIOCETHTOOL:

         dev_load(net, ifr.ifr_name);

         rtnl_lock();

         ret = dev_ethtool(net, &ifr);

         rtnl_unlock();

         if (!ret) {

             if (colon)

                 *colon = ':';

             if (copy_to_user(arg, &ifr,

                      sizeof(struct ifreq)))

                 ret = -EFAULT;

         }

         return ret;

     /*

      *    These ioctl calls:

      *    - require superuser power.

      *    - require strict serialization.

      *    - return a value

      */

     case SIOCGMIIPHY:

     case SIOCGMIIREG:

     case SIOCSIFNAME:

         if (!capable(CAP_NET_ADMIN))

             return -EPERM;

         dev_load(net, ifr.ifr_name);

         rtnl_lock();

         ret = dev_ifsioc(net, &ifr, cmd);

         rtnl_unlock();

         if (!ret) {

             if (colon)

                 *colon = ':';

             if (copy_to_user(arg, &ifr,

                      sizeof(struct ifreq)))

                 ret = -EFAULT;

         }

         return ret;

     /*

      *    These ioctl calls:

      *    - require superuser power.

      *    - require strict serialization.

      *    - do not return a value

      */

     case SIOCSIFFLAGS:

     case SIOCSIFMETRIC:

     case SIOCSIFMTU:

     case SIOCSIFMAP:

     case SIOCSIFHWADDR:

     case SIOCSIFSLAVE:

     case SIOCADDMULTI:

     case SIOCDELMULTI:

     case SIOCSIFHWBROADCAST:

     case SIOCSIFTXQLEN:

     case SIOCSMIIREG:

     case SIOCBONDENSLAVE:

     case SIOCBONDRELEASE:

     case SIOCBONDSETHWADDR:

     case SIOCBONDCHANGEACTIVE:

     case SIOCBRADDIF:

     case SIOCBRDELIF:

     case SIOCSHWTSTAMP:

         if (!capable(CAP_NET_ADMIN))

             return -EPERM;

         /* fall through */

     case SIOCBONDSLAVEINFOQUERY:

     case SIOCBONDINFOQUERY:

         dev_load(net, ifr.ifr_name);

         rtnl_lock();

         ret = dev_ifsioc(net, &ifr, cmd);

         rtnl_unlock();

         return ret;

     case SIOCGIFMEM:

         /* Get the per device memory space. We can add this but

          * currently do not support it */

     case SIOCSIFMEM:

         /* Set the per device memory buffer space.

          * Not applicable in our case */

     case SIOCSIFLINK:

         return -ENOTTY;

     /*

      *    Unknown or private ioctl.

      */

     default:

         if (cmd == SIOCWANDEV ||

             (cmd >= SIOCDEVPRIVATE &&

              cmd <= SIOCDEVPRIVATE + )) {

             dev_load(net, ifr.ifr_name);

             rtnl_lock();

             ret = dev_ifsioc(net, &ifr, cmd);

             rtnl_unlock();

             if (!ret && copy_to_user(arg, &ifr,

                          sizeof(struct ifreq)))

                 ret = -EFAULT;

             return ret;

         }

         /* Take care of Wireless Extensions */

         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)

             return wext_handle_ioctl(net, &ifr, cmd, arg);  //执行wext_handle_ioctl方法

         return -ENOTTY;

     }

 }

dev_ioctl

int wext_handle_ioctl(struct net *net, struct ifreq *ifr, unsigned int cmd,

              void __user *arg)

{

    struct iw_request_info info = { .cmd = cmd, .flags =  };

    int ret;

    ret = wext_ioctl_dispatch(net, ifr, cmd, &info,

                  ioctl_standard_call,

                  ioctl_private_call); //调用wext_ioctl_dispatch方法

    if (ret >=  &&

        IW_IS_GET(cmd) &&

        copy_to_user(arg, ifr, sizeof(struct iwreq)))  //将执行结果从kernel态copy到用户态

        return -EFAULT;

    return ret;

}

wext_handle_ioctl

 /* entry point from dev ioctl */

 static int wext_ioctl_dispatch(struct net *net, struct ifreq *ifr,

                    unsigned int cmd, struct iw_request_info *info,

                    wext_ioctl_func standard,

                    wext_ioctl_func private)

 {

     int ret = wext_permission_check(cmd);

     if (ret)

         return ret;

     dev_load(net, ifr->ifr_name);

     rtnl_lock();

     ret = wireless_process_ioctl(net, ifr, cmd, info, standard, private); //调用wireless_process_ioctl方法

     rtnl_unlock();

     return ret;

 }

wext_ioctl_dispatch

 /*

  * Main IOCTl dispatcher.

  * Check the type of IOCTL and call the appropriate wrapper...

  */

 static int wireless_process_ioctl(struct net *net, struct ifreq *ifr,

                   unsigned int cmd,

                   struct iw_request_info *info,

                   wext_ioctl_func standard,

                   wext_ioctl_func private)

 {

     struct iwreq *iwr = (struct iwreq *) ifr;

     struct net_device *dev;

     iw_handler    handler;

     /* Permissions are already checked in dev_ioctl() before calling us.

      * The copy_to/from_user() of ifr is also dealt with in there */

     /* Make sure the device exist */

     if ((dev = __dev_get_by_name(net, ifr->ifr_name)) == NULL)

         return -ENODEV;

     /* A bunch of special cases, then the generic case...

      * Note that 'cmd' is already filtered in dev_ioctl() with

      * (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) */

     if (cmd == SIOCGIWSTATS)

         return standard(dev, iwr, cmd, info,

                 &iw_handler_get_iwstats);

 #ifdef CONFIG_WEXT_PRIV

     if (cmd == SIOCGIWPRIV && dev->wireless_handlers)

         return standard(dev, iwr, cmd, info,

                 iw_handler_get_private);

 #endif

     /* Basic check */

     if (!netif_device_present(dev))

         return -ENODEV;

     /* New driver API : try to find the handler */

     handler = get_handler(dev, cmd);  //调用get_handler

     if (handler) {

         /* Standard and private are not the same */

         if (cmd < SIOCIWFIRSTPRIV)

             return standard(dev, iwr, cmd, info, handler);

         else if (private)

             return private(dev, iwr, cmd, info, handler);

     }

     /* Old driver API : call driver ioctl handler */

     if (dev->netdev_ops->ndo_do_ioctl)

         return dev->netdev_ops->ndo_do_ioctl(dev, ifr, cmd);

     return -EOPNOTSUPP;

 }

wireless_process_ioctl

 /*

  * Wrapper to call a standard Wireless Extension handler.

  * We do various checks and also take care of moving data between

  * user space and kernel space.

  */

 static int ioctl_standard_call(struct net_device *    dev,

                    struct iwreq        *iwr,

                    unsigned int        cmd,

                    struct iw_request_info    *info,

                    iw_handler        handler)

 {

     const struct iw_ioctl_description *    descr;

     int                    ret = -EINVAL;

     /* Get the description of the IOCTL */

     if (IW_IOCTL_IDX(cmd) >= standard_ioctl_num)

         return -EOPNOTSUPP;

     descr = &(standard_ioctl[IW_IOCTL_IDX(cmd)]);

     /* Check if we have a pointer to user space data or not */

     if (descr->header_type != IW_HEADER_TYPE_POINT) {

         /* No extra arguments. Trivial to handle */

         ret = handler(dev, info, &(iwr->u), NULL);

         /* Generate an event to notify listeners of the change */

         if ((descr->flags & IW_DESCR_FLAG_EVENT) &&

            ((ret == ) || (ret == -EIWCOMMIT)))

             wireless_send_event(dev, cmd, &(iwr->u), NULL);

     } else {

         ret = ioctl_standard_iw_point(&iwr->u.data, cmd, descr,

                           handler, dev, info);

     }

     /* Call commit handler if needed and defined */

     if (ret == -EIWCOMMIT)

         ret = call_commit_handler(dev);

     /* Here, we will generate the appropriate event if needed */

     return ret;

 }

ioctl_standard_call

struct netlink_data * netlink_init(struct netlink_config *cfg)

{

    struct netlink_data *netlink;

    struct sockaddr_nl local; 

    netlink = os_zalloc(sizeof(*netlink));

    if (netlink == NULL)

        return NULL;

    netlink->cfg = cfg;

    netlink->sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);

    if (netlink->sock < ) {

        wpa_printf(MSG_ERROR, "netlink: Failed to open netlink "

               "socket: %s", strerror(errno));

        netlink_deinit(netlink);

        return NULL;

    }

    os_memset(&local, , sizeof(local));

    local.nl_family = AF_NETLINK;

    local.nl_groups = RTMGRP_LINK;

    if (bind(netlink->sock, (struct sockaddr *) &local, sizeof(local)) < )

    {

        wpa_printf(MSG_ERROR, "netlink: Failed to bind netlink "

               "socket: %s", strerror(errno));

        netlink_deinit(netlink);

        return NULL;

    }

    eloop_register_read_sock(netlink->sock, netlink_receive, netlink,

                 NULL);

    return netlink;

}

static void netlink_receive(int sock, void *eloop_ctx, void *sock_ctx)

{

    struct netlink_data *netlink = eloop_ctx;

    char buf[];

    int left;

    struct sockaddr_nl from;

    socklen_t fromlen;

    struct nlmsghdr *h;

    int max_events = ;

try_again:

    fromlen = sizeof(from);

    left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT,

            (struct sockaddr *) &from, &fromlen); //从netlink读取事件

    if (left < ) {

        if (errno != EINTR && errno != EAGAIN)

            wpa_printf(MSG_INFO, "netlink: recvfrom failed: %s",

                   strerror(errno));

        return;

    }

    h = (struct nlmsghdr *) buf;

    while (NLMSG_OK(h, left)) {

        switch (h->nlmsg_type) {

        case RTM_NEWLINK:

            netlink_receive_link(netlink, netlink->cfg->newlink_cb,

                         h); //a

            break;

        case RTM_DELLINK:

            netlink_receive_link(netlink, netlink->cfg->dellink_cb,

                         h);  //b

            break;

        }

        h = NLMSG_NEXT(h, left);

    }

    if (left > ) {

        wpa_printf(MSG_DEBUG, "netlink: %d extra bytes in the end of "

               "netlink message", left);

    }

    if (--max_events > ) {

        /*

         * Try to receive all events in one eloop call in order to

         * limit race condition on cases where AssocInfo event, Assoc

         * event, and EAPOL frames are received more or less at the

         * same time. We want to process the event messages first

         * before starting EAPOL processing.

         */

        goto try_again;

    }

}

cfg->ctx = global;

cfg->newlink_cb = wpa_driver_nl80211_event_rtm_newlink;

cfg->dellink_cb = wpa_driver_nl80211_event_rtm_dellink;