Ticket #509: madwifi-large-scan-results.patch

File madwifi-large-scan-results.patch, 12.5 kB (added by Chris.Hessing@utah.edu, 6 years ago)
  • madwifi-ng/net80211/ieee80211_scan_ap.c

    old new  
    367367        /* XXX is there anything meaningful to do? */ 
    368368} 
    369369 
    370 static void 
     370static int 
    371371ap_iterate(struct ieee80211_scan_state *ss, 
    372372        ieee80211_scan_iter_func *f, void *arg) 
    373373{ 
    374374        /* NB: nothing meaningful we can do */ 
     375  return 0; 
    375376} 
    376377 
    377378static void 
  • madwifi-ng/net80211/ieee80211_scan.c

    old new  
    922922/* 
    923923 * Iterate over the contents of the scan cache. 
    924924 */ 
    925 void 
     925int 
    926926ieee80211_scan_iterate(struct ieee80211com *ic, 
    927927        ieee80211_scan_iter_func *f, void *arg) 
    928928{ 
     929  int res = 0; 
    929930        struct ieee80211_scan_state *ss = ic->ic_scan; 
    930931 
    931932        if (ss->ss_ops != NULL) 
    932                 ss->ss_ops->scan_iterate(ss, f, arg); 
     933          { 
     934                res = ss->ss_ops->scan_iterate(ss, f, arg); 
     935                printk("scan iterate returned %d\n", res); 
     936          } 
     937        return res; 
    933938} 
    934939 
    935940/* 
  • madwifi-ng/net80211/ieee80211_scan.h

    old new  
    113113void ieee80211_scan_flush(struct ieee80211com *); 
    114114 
    115115struct ieee80211_scan_entry; 
    116 typedef void ieee80211_scan_iter_func(void *, const struct ieee80211_scan_entry *); 
    117 void ieee80211_scan_iterate(struct ieee80211com *, ieee80211_scan_iter_func, void *); 
     116typedef int ieee80211_scan_iter_func(void *, const struct ieee80211_scan_entry *); 
     117int ieee80211_scan_iterate(struct ieee80211com *, ieee80211_scan_iter_func, void *); 
    118118 
    119119/* 
    120120 * Parameters supplied when adding/updating an entry in a 
     
    205205        void (*scan_assoc_success)(struct ieee80211_scan_state *, 
    206206                const u_int8_t macaddr[IEEE80211_ADDR_LEN]); 
    207207        /* iterate over entries in the scan cache */ 
    208         void (*scan_iterate)(struct ieee80211_scan_state *, 
    209                 ieee80211_scan_iter_func *, void *); 
     208        int (*scan_iterate)(struct ieee80211_scan_state *, 
     209                           ieee80211_scan_iter_func *, void *); 
    210210        /* default action to take when found scan match */ 
    211211        int (*scan_default)(struct ieee80211vap *, 
    212212                const struct ieee80211_scan_entry *); 
  • madwifi-ng/net80211/ieee80211_scan_sta.c

    old new  
    10401040 * Iterate over the entries in the scan cache, invoking 
    10411041 * the callback function on each one. 
    10421042 */ 
    1043 static void 
     1043static int 
    10441044sta_iterate(struct ieee80211_scan_state *ss,  
    10451045        ieee80211_scan_iter_func *f, void *arg) 
    10461046{ 
    10471047        struct sta_table *st = ss->ss_priv; 
    10481048        struct sta_entry *se; 
    10491049        u_int gen; 
     1050        int res = 0; 
    10501051 
    10511052        spin_lock_bh(&st->st_scanlock); 
    10521053        gen = st->st_scangen++; 
     
    10581059                        /* update public state */ 
    10591060                        se->base.se_age = jiffies - se->se_lastupdate; 
    10601061                        spin_unlock(&st->st_lock); 
    1061                         (*f)(arg, &se->base); 
     1062                        res = (*f)(arg, &se->base); 
     1063 
     1064                        if (res != 0) 
     1065                          { 
     1066                            // We probably ran out of buffer space. 
     1067                            goto done; 
     1068                          } 
    10621069                        goto restart; 
    10631070                } 
    10641071        } 
     1072 
    10651073        spin_unlock(&st->st_lock); 
    10661074 
     1075done: 
    10671076        spin_unlock_bh(&st->st_scanlock); 
     1077 
     1078        return res; 
    10681079} 
    10691080 
    10701081static void 
  • madwifi-ng/net80211/ieee80211_wireless.c

    old new  
    13301330        int i; 
    13311331}; 
    13321332 
    1333 static void 
     1333static int 
    13341334waplist_cb(void *arg, const struct ieee80211_scan_entry *se) 
    13351335{ 
    13361336        struct waplistreq *req = arg; 
    13371337        int i = req->i; 
    13381338 
    13391339        if (i >= IW_MAX_AP) 
    1340                 return
     1340                return 0
    13411341        req->addr[i].sa_family = ARPHRD_ETHER; 
    13421342        if (req->vap->iv_opmode == IEEE80211_M_HOSTAP) 
    13431343                IEEE80211_ADDR_COPY(req->addr[i].sa_data, se->se_macaddr); 
     
    13451345                IEEE80211_ADDR_COPY(req->addr[i].sa_data, se->se_bssid); 
    13461346        set_quality(&req->qual[i], se->se_rssi); 
    13471347        req->i = i + 1; 
     1348 
     1349        return 0; 
    13481350} 
    13491351 
    13501352static int 
     
    14271429        int mode; 
    14281430}; 
    14291431 
    1430 static void 
     1432static int 
    14311433giwscan_cb(void *arg, const struct ieee80211_scan_entry *se) 
    14321434{ 
    14331435        struct iwscanreq *req = arg; 
    14341436        struct ieee80211vap *vap = req->vap; 
    14351437        char *current_ev = req->current_ev; 
    14361438        char *end_buf = req->end_buf; 
     1439        char *last_ev; 
    14371440#if WIRELESS_EXT > 14 
    14381441        char buf[64 * 2 + 30]; 
    14391442#endif 
     
    14421445        int j; 
    14431446 
    14441447        if (current_ev >= end_buf) 
    1445                 return; 
     1448            return E2BIG; 
     1449 
    14461450        /* WPA/!WPA sort criteria */ 
    14471451        if ((req->mode != 0) ^ (se->se_wpa_ie != NULL)) 
    1448                 return
     1452                return 0
    14491453 
    14501454        memset(&iwe, 0, sizeof(iwe)); 
     1455        last_ev = current_ev; 
    14511456        iwe.cmd = SIOCGIWAP; 
    14521457        iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 
    14531458        if (vap->iv_opmode == IEEE80211_M_HOSTAP) 
     
    14561461                IEEE80211_ADDR_COPY(iwe.u.ap_addr.sa_data, se->se_bssid); 
    14571462        current_ev = iwe_stream_add_event(current_ev, end_buf, &iwe, IW_EV_ADDR_LEN); 
    14581463 
     1464        // We ran out of space in the buffer. 
     1465        if (last_ev == current_ev)  
     1466            return E2BIG; 
     1467 
    14591468        memset(&iwe, 0, sizeof(iwe)); 
     1469        last_ev = current_ev; 
    14601470        iwe.cmd = SIOCGIWESSID; 
    14611471        iwe.u.data.flags = 1; 
    14621472        if (vap->iv_opmode == IEEE80211_M_HOSTAP) { 
     
    14701480                        end_buf, &iwe, (char *) se->se_ssid+2); 
    14711481        } 
    14721482 
     1483        // We ran out of space in the buffer. 
     1484        if (last_ev == current_ev)  
     1485            return E2BIG; 
     1486 
    14731487        if (se->se_capinfo & (IEEE80211_CAPINFO_ESS|IEEE80211_CAPINFO_IBSS)) { 
    14741488                memset(&iwe, 0, sizeof(iwe)); 
     1489                last_ev = current_ev; 
    14751490                iwe.cmd = SIOCGIWMODE; 
    14761491                iwe.u.mode = se->se_capinfo & IEEE80211_CAPINFO_ESS ? 
    14771492                        IW_MODE_MASTER : IW_MODE_ADHOC; 
    14781493                current_ev = iwe_stream_add_event(current_ev, 
    14791494                        end_buf, &iwe, IW_EV_UINT_LEN); 
     1495 
     1496                // We ran out of space in the buffer. 
     1497                if (last_ev == current_ev)  
     1498                    return E2BIG; 
    14801499        } 
    14811500 
    14821501        memset(&iwe, 0, sizeof(iwe)); 
     1502        last_ev = current_ev; 
    14831503        iwe.cmd = SIOCGIWFREQ; 
    14841504        iwe.u.freq.m = se->se_chan->ic_freq * 100000; 
    14851505        iwe.u.freq.e = 1; 
    14861506        current_ev = iwe_stream_add_event(current_ev, 
    14871507                end_buf, &iwe, IW_EV_FREQ_LEN); 
    14881508 
     1509        // We ran out of space in the buffer. 
     1510        if (last_ev == current_ev)  
     1511            return E2BIG; 
     1512 
    14891513        memset(&iwe, 0, sizeof(iwe)); 
     1514        last_ev = current_ev; 
    14901515        iwe.cmd = IWEVQUAL; 
    14911516        set_quality(&iwe.u.qual, se->se_rssi); 
    14921517        current_ev = iwe_stream_add_event(current_ev, 
    14931518                end_buf, &iwe, IW_EV_QUAL_LEN); 
    14941519 
     1520        // We ran out of space in the buffer. 
     1521        if (last_ev == current_ev)  
     1522            return E2BIG; 
     1523 
    14951524        memset(&iwe, 0, sizeof(iwe)); 
     1525        last_ev = current_ev; 
    14961526        iwe.cmd = SIOCGIWENCODE; 
    14971527        if (se->se_capinfo & IEEE80211_CAPINFO_PRIVACY) 
    14981528                iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; 
     
    15011531        iwe.u.data.length = 0; 
    15021532        current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, ""); 
    15031533 
     1534        // We ran out of space in the buffer. 
     1535        if (last_ev == current_ev)  
     1536            return E2BIG; 
     1537 
    15041538        memset(&iwe, 0, sizeof(iwe)); 
     1539        last_ev = current_ev; 
    15051540        iwe.cmd = SIOCGIWRATE; 
    15061541        current_val = current_ev + IW_EV_LCP_LEN; 
    15071542        /* NB: not sorted, does it matter? */ 
     
    15251560        } 
    15261561        /* remove fixed header if no rates were added */ 
    15271562        if ((current_val - current_ev) > IW_EV_LCP_LEN) 
     1563          { 
    15281564                current_ev = current_val; 
     1565          } 
     1566        else 
     1567          { 
     1568            // We ran out of space in the buffer. 
     1569            if (last_ev == current_ev) 
     1570              return E2BIG; 
     1571          } 
    15291572 
    15301573#if WIRELESS_EXT > 14 
    15311574        memset(&iwe, 0, sizeof(iwe)); 
     1575        last_ev = current_ev; 
    15321576        iwe.cmd = IWEVCUSTOM; 
    15331577        snprintf(buf, sizeof(buf), "bcn_int=%d", se->se_intval); 
    15341578        iwe.u.data.length = strlen(buf); 
    15351579        current_ev = iwe_stream_add_point(current_ev, end_buf, &iwe, buf); 
    15361580 
     1581        // We ran out of space in the buffer. 
     1582        if (last_ev == current_ev)  
     1583            return E2BIG; 
     1584 
    15371585        if (se->se_rsn_ie != NULL) { 
    15381586                static const char rsn_leader[] = "rsn_ie="; 
    15391587 
    15401588                memset(&iwe, 0, sizeof(iwe)); 
     1589                last_ev = current_ev; 
    15411590                iwe.cmd = IWEVCUSTOM; 
    15421591                if (se->se_rsn_ie[0] == IEEE80211_ELEMID_RSN) 
    15431592                        iwe.u.data.length = encode_ie(buf, sizeof(buf), 
    15441593                                se->se_rsn_ie, se->se_rsn_ie[1] + 2, 
    15451594                                rsn_leader, sizeof(rsn_leader) - 1); 
    15461595                if (iwe.u.data.length != 0) 
     1596                  { 
    15471597                        current_ev = iwe_stream_add_point(current_ev, end_buf, 
    15481598                                &iwe, buf); 
     1599 
     1600                        // We ran out of space in the buffer. 
     1601                        if (last_ev == current_ev)  
     1602                          return E2BIG; 
     1603                  } 
    15491604        } 
    15501605        if (se->se_wpa_ie != NULL) { 
    15511606                static const char wpa_leader[] = "wpa_ie="; 
    15521607 
    15531608                memset(&iwe, 0, sizeof(iwe)); 
     1609                last_ev = current_ev; 
    15541610                iwe.cmd = IWEVCUSTOM; 
    15551611                iwe.u.data.length = encode_ie(buf, sizeof(buf), 
    15561612                        se->se_wpa_ie, se->se_wpa_ie[1] + 2, 
    15571613                        wpa_leader, sizeof(wpa_leader) - 1); 
    15581614                if (iwe.u.data.length != 0) 
     1615                  { 
    15591616                        current_ev = iwe_stream_add_point(current_ev, end_buf, 
    15601617                                &iwe, buf); 
     1618 
     1619                        // We ran out of space in the buffer. 
     1620                        if (last_ev == current_ev)  
     1621                          return E2BIG; 
     1622                  } 
    15611623        } 
    15621624        if (se->se_wme_ie != NULL) { 
    15631625                static const char wme_leader[] = "wme_ie="; 
    15641626 
    15651627                memset(&iwe, 0, sizeof(iwe)); 
     1628                last_ev = current_ev; 
    15661629                iwe.cmd = IWEVCUSTOM; 
    15671630                iwe.u.data.length = encode_ie(buf, sizeof(buf), 
    15681631                        se->se_wme_ie, se->se_wme_ie[1] + 2, 
    15691632                        wme_leader, sizeof(wme_leader) - 1); 
    15701633                if (iwe.u.data.length != 0) 
     1634                  { 
    15711635                        current_ev = iwe_stream_add_point(current_ev, end_buf, 
    15721636                                &iwe, buf); 
     1637 
     1638                        // We ran out of space in the buffer. 
     1639                        if (last_ev == current_ev)  
     1640                          return E2BIG; 
     1641                  } 
    15731642        } 
    15741643        if (se->se_ath_ie != NULL) { 
    15751644                static const char ath_leader[] = "ath_ie="; 
    15761645 
    15771646                memset(&iwe, 0, sizeof(iwe)); 
     1647                last_ev = current_ev; 
    15781648                iwe.cmd = IWEVCUSTOM; 
    15791649                iwe.u.data.length = encode_ie(buf, sizeof(buf), 
    15801650                        se->se_ath_ie, se->se_ath_ie[1] + 2, 
    15811651                        ath_leader, sizeof(ath_leader) - 1); 
    15821652                if (iwe.u.data.length != 0) 
     1653                  { 
    15831654                        current_ev = iwe_stream_add_point(current_ev, end_buf, 
    15841655                                &iwe, buf); 
     1656 
     1657                        // We ran out of space in the buffer. 
     1658                        if (last_ev == current_ev)  
     1659                          return E2BIG; 
     1660                  } 
    15851661        } 
    15861662#endif /* WIRELESS_EXT > 14 */ 
    15871663        req->current_ev = current_ev; 
     1664 
     1665        return 0; 
    15881666} 
    15891667 
    15901668static int 
     
    15941672        struct ieee80211vap *vap = dev->priv; 
    15951673        struct ieee80211com *ic = vap->iv_ic; 
    15961674        struct iwscanreq req; 
     1675        int res = 0; 
    15971676 
    15981677        req.vap = vap; 
    15991678        req.current_ev = extra; 
    1600         req.end_buf = extra + IW_SCAN_MAX_DATA; 
     1679        if (data->length == 0) 
     1680          { 
     1681            req.end_buf = extra + IW_SCAN_MAX_DATA; 
     1682          } 
     1683        else 
     1684          { 
     1685            req.end_buf = extra + data->length; 
     1686          } 
    16011687 
    16021688        /* 
     1689         * XXX -- This is no longer needed, as long as the caller supports 
     1690         * large scan results.  - CH 
     1691         * 
    16031692         * Do two passes to ensure WPA/non-WPA scan candidates 
    16041693         * are sorted to the front.  This is a hack to deal with 
    16051694         * the wireless extensions capping scan results at 
     
    16091698         * guarantee we won't overflow anyway. 
    16101699         */ 
    16111700        req.mode = vap->iv_flags & IEEE80211_F_WPA; 
    1612         ieee80211_scan_iterate(ic, giwscan_cb, &req); 
    1613         req.mode = req.mode ? 0 : IEEE80211_F_WPA; 
    1614         ieee80211_scan_iterate(ic, giwscan_cb, &req); 
     1701        res = ieee80211_scan_iterate(ic, giwscan_cb, &req); 
     1702        if (res == 0) 
     1703          { 
     1704            req.mode = req.mode ? 0 : IEEE80211_F_WPA; 
     1705            res = ieee80211_scan_iterate(ic, giwscan_cb, &req); 
     1706          } 
    16151707 
    16161708        data->length = req.current_ev - extra; 
    1617         return 0; 
     1709 
     1710        if (res != 0) 
     1711          { 
     1712            return -res; 
     1713          } 
     1714        return res; 
    16181715} 
    16191716#endif /* SIOCGIWSCAN */ 
    16201717 
     
    28022899/* 
    28032900 * Match mac address and any ssid. 
    28042901 */ 
    2805 static void 
     2902static int 
    28062903mlmelookup(void *arg, const struct ieee80211_scan_entry *se) 
    28072904{ 
    28082905        struct scanlookup *look = arg; 
    28092906 
    28102907        if (!IEEE80211_ADDR_EQ(look->mac, se->se_macaddr)) 
    2811                 return
     2908                return 0
    28122909        if (look->esslen != 0) { 
    28132910                if (se->se_ssid[1] != look->esslen) 
    2814                         return
     2911                        return 0
    28152912                if (memcmp(look->essid, se->se_ssid + 2, look->esslen)) 
    2816                         return
     2913                        return 0
    28172914        } 
    28182915        look->se = se; 
     2916 
     2917        return 0; 
    28192918} 
    28202919 
    28212920static int 
     
    33193418                se->se_ssid[1] + *ielen, sizeof(u_int32_t)); 
    33203419} 
    33213420 
    3322 static void 
     3421static int 
    33233422get_scan_space(void *arg, const struct ieee80211_scan_entry *se) 
    33243423{ 
    33253424        struct scanreq *req = arg; 
    33263425        int ielen; 
    33273426 
    33283427        req->space += scan_space(se, &ielen); 
     3428 
     3429        return 0; 
    33293430} 
    33303431 
    3331 static void 
     3432static int 
    33323433get_scan_result(void *arg, const struct ieee80211_scan_entry *se) 
    33333434{ 
    33343435        struct scanreq *req = arg; 
     
    33383439 
    33393440        len = scan_space(se, &ielen); 
    33403441        if (len > req->space) 
    3341                 return; 
     3442          { 
     3443            printk("[madwifi] %s() : Not enough space.\n", __FUNCTION__); 
     3444                return 0; 
     3445          } 
    33423446 
    33433447        sr = req->sr; 
    33443448        memset(sr, 0, sizeof(*sr)); 
     
    33823486 
    33833487        req->space -= len; 
    33843488        req->sr = (struct ieee80211req_scan_result *)(((u_int8_t *)sr) + len); 
     3489 
     3490        return 0; 
    33853491} 
    33863492 
    33873493static int