* [PATCH] mac80211: refactor association @ 2009-12-03 19:41 Johannes Berg 2009-12-04 7:52 ` [PATCH v2] " Johannes Berg 0 siblings, 1 reply; 2+ messages in thread From: Johannes Berg @ 2009-12-03 19:41 UTC (permalink / raw) To: John Linville; +Cc: linux-wireless UmVmYWN0b3IgdGhlIGNvZGUgdG8gcmVzZXJ2ZSBhbiBza2Igb2YgdGhlIHJpZ2h0IHNpemUKKGlu c3RlYWQgb2YgaG9waW5nIDIwMCBieXRlcyBhcmUgZW5vdWdoIGZvcmV2ZXIpLCBhbmQKYWxzbyBw dXQgSFQgSUUgZ2VuZXJhdGlvbiBpbnRvIGFuIG93biBmdW5jdGlvbi4KCkFkZGl0aW9uYWxseSwg cHV0IHRoZSBIVCBJRSBiZWZvcmUgdGhlIHZlbmRvci1zcGVjaWZpYwpXTU0gSUUuIFRoaXMgc3Rp bGwgbGVhdmVzIHRoaW5ncyBub3QgcXVpdGUgb3JkZXJlZApjb3JyZWN0bHksIGR1ZSB0byB1c2Vy LXNwZWNpZmllZCBJRXMsIGFkZCBhIG5vdGUgYWJvdXQKdGhhdCBmb3Igbm93LgoKU2lnbmVkLW9m Zi1ieTogSm9oYW5uZXMgQmVyZyA8am9oYW5uZXNAc2lwc29sdXRpb25zLm5ldD4KLS0tCiBuZXQv bWFjODAyMTEvbWxtZS5jIHwgICAgNyArCiBuZXQvbWFjODAyMTEvd29yay5jIHwgIDIzOSArKysr KysrKysrKysrKysrKysrKysrKysrKysrLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAyIGZpbGVz IGNoYW5nZWQsIDEzNyBpbnNlcnRpb25zKCspLCAxMDkgZGVsZXRpb25zKC0pCgotLS0gd2lyZWxl c3MtdGVzdGluZy5vcmlnL25ldC9tYWM4MDIxMS93b3JrLmMJMjAwOS0xMi0wMyAxNjoyODoyMC4w MDAwMDAwMDAgKzAxMDAKKysrIHdpcmVsZXNzLXRlc3RpbmcvbmV0L21hYzgwMjExL3dvcmsuYwky MDA5LTEyLTAzIDIwOjMzOjIwLjAwMDAwMDAwMCArMDEwMApAQCAtMTAwLDYgKzEwMCwxMDIgQEAg c3RhdGljIGludCBpZWVlODAyMTFfY29tcGF0aWJsZV9yYXRlcyhjbwogCiAvKiBmcmFtZSBzZW5k aW5nIGZ1bmN0aW9ucyAqLwogCitzdGF0aWMgdm9pZCBpZWVlODAyMTFfYWRkX2h0X2llKHN0cnVj dCBza19idWZmICpza2IsIGNvbnN0IHU4ICpodF9pbmZvX2llLAorCQkJCXN0cnVjdCBpZWVlODAy MTFfc3VwcG9ydGVkX2JhbmQgKnNiYW5kLAorCQkJCXN0cnVjdCBpZWVlODAyMTFfY2hhbm5lbCAq Y2hhbm5lbCwKKwkJCQllbnVtIGllZWU4MDIxMV9zbXBzX21vZGUgc21wcykKK3sKKwlzdHJ1Y3Qg aWVlZTgwMjExX2h0X2luZm8gKmh0X2luZm87CisJdTggKnBvczsKKwl1MzIgZmxhZ3MgPSBjaGFu bmVsLT5mbGFnczsKKwl1MTYgY2FwID0gc2JhbmQtPmh0X2NhcC5jYXA7CisJX19sZTE2IHRtcDsK KworCWlmICghc2JhbmQtPmh0X2NhcC5odF9zdXBwb3J0ZWQpCisJCXJldHVybjsKKworCWlmICgh aHRfaW5mb19pZSkKKwkJcmV0dXJuOworCisJaWYgKGh0X2luZm9faWVbMV0gPCBzaXplb2Yoc3Ry dWN0IGllZWU4MDIxMV9odF9pbmZvKSkKKwkJcmV0dXJuOworCisJaHRfaW5mbyA9IChzdHJ1Y3Qg aWVlZTgwMjExX2h0X2luZm8gKikoaHRfaW5mb19pZSArIDIpOworCisJLyogZGV0ZXJtaW5lIGNh cGFiaWxpdHkgZmxhZ3MgKi8KKworCWlmIChpZWVlODAyMTFfZGlzYWJsZV80MG1oel8yNGdoeiAm JgorCSAgICBzYmFuZC0+YmFuZCA9PSBJRUVFODAyMTFfQkFORF8yR0haKSB7CisJCWNhcCAmPSB+ SUVFRTgwMjExX0hUX0NBUF9TVVBfV0lEVEhfMjBfNDA7CisJCWNhcCAmPSB+SUVFRTgwMjExX0hU X0NBUF9TR0lfNDA7CisJfQorCisJc3dpdGNoIChodF9pbmZvLT5odF9wYXJhbSAmIElFRUU4MDIx MV9IVF9QQVJBTV9DSEFfU0VDX09GRlNFVCkgeworCWNhc2UgSUVFRTgwMjExX0hUX1BBUkFNX0NI QV9TRUNfQUJPVkU6CisJCWlmIChmbGFncyAmIElFRUU4MDIxMV9DSEFOX05PX0hUNDBQTFVTKSB7 CisJCQljYXAgJj0gfklFRUU4MDIxMV9IVF9DQVBfU1VQX1dJRFRIXzIwXzQwOworCQkJY2FwICY9 IH5JRUVFODAyMTFfSFRfQ0FQX1NHSV80MDsKKwkJfQorCQlicmVhazsKKwljYXNlIElFRUU4MDIx MV9IVF9QQVJBTV9DSEFfU0VDX0JFTE9XOgorCQlpZiAoZmxhZ3MgJiBJRUVFODAyMTFfQ0hBTl9O T19IVDQwTUlOVVMpIHsKKwkJCWNhcCAmPSB+SUVFRTgwMjExX0hUX0NBUF9TVVBfV0lEVEhfMjBf NDA7CisJCQljYXAgJj0gfklFRUU4MDIxMV9IVF9DQVBfU0dJXzQwOworCQl9CisJCWJyZWFrOwor CX0KKworCS8qIHNldCBTTSBQUyBtb2RlIHByb3Blcmx5ICovCisJY2FwICY9IH5JRUVFODAyMTFf SFRfQ0FQX1NNX1BTOworCXN3aXRjaCAoc21wcykgeworCWNhc2UgSUVFRTgwMjExX1NNUFNfQVVU T01BVElDOgorCWNhc2UgSUVFRTgwMjExX1NNUFNfTlVNX01PREVTOgorCQlXQVJOX09OKDEpOwor CWNhc2UgSUVFRTgwMjExX1NNUFNfT0ZGOgorCQljYXAgfD0gV0xBTl9IVF9DQVBfU01fUFNfRElT QUJMRUQgPDwKKwkJCUlFRUU4MDIxMV9IVF9DQVBfU01fUFNfU0hJRlQ7CisJCWJyZWFrOworCWNh c2UgSUVFRTgwMjExX1NNUFNfU1RBVElDOgorCQljYXAgfD0gV0xBTl9IVF9DQVBfU01fUFNfU1RB VElDIDw8CisJCQlJRUVFODAyMTFfSFRfQ0FQX1NNX1BTX1NISUZUOworCQlicmVhazsKKwljYXNl IElFRUU4MDIxMV9TTVBTX0RZTkFNSUM6CisJCWNhcCB8PSBXTEFOX0hUX0NBUF9TTV9QU19EWU5B TUlDIDw8CisJCQlJRUVFODAyMTFfSFRfQ0FQX1NNX1BTX1NISUZUOworCQlicmVhazsKKwl9CisK KwkvKiByZXNlcnZlIGFuZCBmaWxsIElFICovCisKKwlwb3MgPSBza2JfcHV0KHNrYiwgc2l6ZW9m KHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwKSArIDIpOworCSpwb3MrKyA9IFdMQU5fRUlEX0hUX0NB UEFCSUxJVFk7CisJKnBvcysrID0gc2l6ZW9mKHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwKTsKKwlt ZW1zZXQocG9zLCAwLCBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV9odF9jYXApKTsKKworCS8qIGNh cGFiaWxpdHkgZmxhZ3MgKi8KKwl0bXAgPSBjcHVfdG9fbGUxNihjYXApOworCW1lbWNweShwb3Ms ICZ0bXAsIHNpemVvZih1MTYpKTsKKwlwb3MgKz0gc2l6ZW9mKHUxNik7CisKKwkvKiBBTVBEVSBw YXJhbWV0ZXJzICovCisJKnBvcysrID0gc2JhbmQtPmh0X2NhcC5hbXBkdV9mYWN0b3IgfAorCQkg KHNiYW5kLT5odF9jYXAuYW1wZHVfZGVuc2l0eSA8PAorCQkJSUVFRTgwMjExX0hUX0FNUERVX1BB Uk1fREVOU0lUWV9TSElGVCk7CisKKwkvKiBNQ1Mgc2V0ICovCisJbWVtY3B5KHBvcywgJnNiYW5k LT5odF9jYXAubWNzLCBzaXplb2Yoc2JhbmQtPmh0X2NhcC5tY3MpKTsKKwlwb3MgKz0gc2l6ZW9m KHNiYW5kLT5odF9jYXAubWNzKTsKKworCS8qIGV4dGVuZGVkIGNhcGFiaWxpdGllcyAqLworCXBv cyArPSBzaXplb2YoX19sZTE2KTsKKworCS8qIEJGIGNhcGFiaWxpdGllcyAqLworCXBvcyArPSBz aXplb2YoX19sZTMyKTsKKworCS8qIGFudGVubmEgc2VsZWN0aW9uICovCisJcG9zICs9IHNpemVv Zih1OCk7Cit9CisKIHN0YXRpYyB2b2lkIGllZWU4MDIxMV9zZW5kX2Fzc29jKHN0cnVjdCBpZWVl ODAyMTFfc3ViX2lmX2RhdGEgKnNkYXRhLAogCQkJCSBzdHJ1Y3QgaWVlZTgwMjExX3dvcmsgKndr KQogewpAQCAtMTA3LDE1ICsyMDMsMzQgQEAgc3RhdGljIHZvaWQgaWVlZTgwMjExX3NlbmRfYXNz b2Moc3RydWN0IAogCXN0cnVjdCBza19idWZmICpza2I7CiAJc3RydWN0IGllZWU4MDIxMV9tZ210 ICptZ210OwogCXU4ICpwb3M7Ci0JY29uc3QgdTggKmllcywgKmh0X2llOworCWNvbnN0IHU4ICpp ZXM7CiAJaW50IGksIGxlbiwgY291bnQsIHJhdGVzX2xlbiwgc3VwcF9yYXRlc19sZW47CiAJdTE2 IGNhcGFiOwogCXN0cnVjdCBpZWVlODAyMTFfc3VwcG9ydGVkX2JhbmQgKnNiYW5kOwogCXUzMiBy YXRlcyA9IDA7CiAKLQlza2IgPSBkZXZfYWxsb2Nfc2tiKGxvY2FsLT5ody5leHRyYV90eF9oZWFk cm9vbSArCi0JCQkgICAgc2l6ZW9mKCptZ210KSArIDIwMCArIHdrLT5pZV9sZW4gKwotCQkJICAg IHdrLT5hc3NvYy5zc2lkX2xlbik7CisJc2JhbmQgPSBsb2NhbC0+aHcud2lwaHktPmJhbmRzW3dr LT5jaGFuLT5iYW5kXTsKKworCS8qCisJICogR2V0IGFsbCByYXRlcyBzdXBwb3J0ZWQgYnkgdGhl IGRldmljZSBhbmQgdGhlIEFQIGFzCisJICogc29tZSBBUHMgZG9uJ3QgbGlrZSBnZXR0aW5nIGEg c3VwZXJzZXQgb2YgdGhlaXIgcmF0ZXMKKwkgKiBpbiB0aGUgYXNzb2NpYXRpb24gcmVxdWVzdCAo ZS5nLiBELUxpbmsgREFQIDEzNTMgaW4KKwkgKiBiLW9ubHkgbW9kZSkuLi4KKwkgKi8KKwlyYXRl c19sZW4gPSBpZWVlODAyMTFfY29tcGF0aWJsZV9yYXRlcyh3ay0+YXNzb2Muc3VwcF9yYXRlcywK KwkJCQkJICAgICAgIHdrLT5hc3NvYy5zdXBwX3JhdGVzX2xlbiwKKwkJCQkJICAgICAgIHNiYW5k LCAmcmF0ZXMpOworCisJc2tiID0gYWxsb2Nfc2tiKGxvY2FsLT5ody5leHRyYV90eF9oZWFkcm9v bSArCisJCQlzaXplb2YoKm1nbXQpICsgLyogYml0IHRvbyBtdWNoIGJ1dCBkb2Vzbid0IG1hdHRl ciAqLworCQkJMiArIHdrLT5hc3NvYy5zc2lkX2xlbiArIC8qIFNTSUQgKi8KKwkJCTQgKyByYXRl c19sZW4gKyAvKiAoZXh0ZW5kZWQpIHJhdGVzICovCisJCQk0ICsgLyogcG93ZXIgY2FwYWJpbGl0 eSAqLworCQkJMiArIDIgKiBzYmFuZC0+bl9jaGFubmVscyArIC8qIHN1cHBvcnRlZCBjaGFubmVs cyAqLworCQkJMiArIHNpemVvZihzdHJ1Y3QgaWVlZTgwMjExX2h0X2NhcCkgKyAvKiBIVCAqLwor CQkJd2stPmllX2xlbiArIC8qIGV4dHJhIElFcyAqLworCQkJOSwgLyogV01NICovCisJCQlHRlBf S0VSTkVMKTsKIAlpZiAoIXNrYikgewogCQlwcmludGsoS0VSTl9ERUJVRyAiJXM6IGZhaWxlZCB0 byBhbGxvY2F0ZSBidWZmZXIgZm9yIGFzc29jICIKIAkJICAgICAgICJmcmFtZVxuIiwgc2RhdGEt Pm5hbWUpOwpAQCAtMTIzLDggKzIzOCw2IEBAIHN0YXRpYyB2b2lkIGllZWU4MDIxMV9zZW5kX2Fz c29jKHN0cnVjdCAKIAl9CiAJc2tiX3Jlc2VydmUoc2tiLCBsb2NhbC0+aHcuZXh0cmFfdHhfaGVh ZHJvb20pOwogCi0Jc2JhbmQgPSBsb2NhbC0+aHcud2lwaHktPmJhbmRzW3drLT5jaGFuLT5iYW5k XTsKLQogCWNhcGFiID0gV0xBTl9DQVBBQklMSVRZX0VTUzsKIAogCWlmIChzYmFuZC0+YmFuZCA9 PSBJRUVFODAyMTFfQkFORF8yR0haKSB7CkBAIC0xMzcsMTYgKzI1MCw2IEBAIHN0YXRpYyB2b2lk IGllZWU4MDIxMV9zZW5kX2Fzc29jKHN0cnVjdCAKIAlpZiAod2stPmFzc29jLmNhcGFiaWxpdHkg JiBXTEFOX0NBUEFCSUxJVFlfUFJJVkFDWSkKIAkJY2FwYWIgfD0gV0xBTl9DQVBBQklMSVRZX1BS SVZBQ1k7CiAKLQkvKgotCSAqIEdldCBhbGwgcmF0ZXMgc3VwcG9ydGVkIGJ5IHRoZSBkZXZpY2Ug YW5kIHRoZSBBUCBhcwotCSAqIHNvbWUgQVBzIGRvbid0IGxpa2UgZ2V0dGluZyBhIHN1cGVyc2V0 IG9mIHRoZWlyIHJhdGVzCi0JICogaW4gdGhlIGFzc29jaWF0aW9uIHJlcXVlc3QgKGUuZy4gRC1M aW5rIERBUCAxMzUzIGluCi0JICogYi1vbmx5IG1vZGUpLi4uCi0JICovCi0JcmF0ZXNfbGVuID0g aWVlZTgwMjExX2NvbXBhdGlibGVfcmF0ZXMod2stPmFzc29jLnN1cHBfcmF0ZXMsCi0JCQkJCSAg ICAgICB3ay0+YXNzb2Muc3VwcF9yYXRlc19sZW4sCi0JCQkJCSAgICAgICBzYmFuZCwgJnJhdGVz KTsKLQogCWlmICgod2stPmFzc29jLmNhcGFiaWxpdHkgJiBXTEFOX0NBUEFCSUxJVFlfU1BFQ1RS VU1fTUdNVCkgJiYKIAkgICAgKGxvY2FsLT5ody5mbGFncyAmIElFRUU4MDIxMV9IV19TUEVDVFJV TV9NR01UKSkKIAkJY2FwYWIgfD0gV0xBTl9DQVBBQklMSVRZX1NQRUNUUlVNX01HTVQ7CkBAIC0y MjAsNyArMzIzLDcgQEAgc3RhdGljIHZvaWQgaWVlZTgwMjExX3NlbmRfYXNzb2Moc3RydWN0IAog CQkqcG9zKysgPSBXTEFOX0VJRF9QV1JfQ0FQQUJJTElUWTsKIAkJKnBvcysrID0gMjsKIAkJKnBv cysrID0gMDsgLyogbWluIHR4IHBvd2VyICovCi0JCSpwb3MrKyA9IGxvY2FsLT5ody5jb25mLmNo YW5uZWwtPm1heF9wb3dlcjsgLyogbWF4IHR4IHBvd2VyICovCisJCSpwb3MrKyA9IHdrLT5jaGFu LT5tYXhfcG93ZXI7IC8qIG1heCB0eCBwb3dlciAqLwogCiAJCS8qIDIuIHN1cHBvcnRlZCBjaGFu bmVscyAqLwogCQkvKiBUT0RPOiBnZXQgdGhpcyBpbiByZWcgZG9tYWluIGZvcm1hdCAqLwpAQCAt MjM0LDExICszMzcsMjEgQEAgc3RhdGljIHZvaWQgaWVlZTgwMjExX3NlbmRfYXNzb2Moc3RydWN0 IAogCQl9CiAJfQogCisJLyoKKwkgKiBYWFg6CVRoZXNlIElFcyBjb3VsZCBjb250YWluICh2ZW5k b3Itc3BlY2lmaWVkKQorCSAqCUlFcyB0aGF0IGJlbG9uZyBhZnRlciBIVCAtLSB0aGUgYnVmZmVy IG1heQorCSAqCW5lZWQgdG8gYmUgc3BsaXQgdXAuCisJICovCiAJaWYgKHdrLT5pZV9sZW4gJiYg d2stPmllKSB7CiAJCXBvcyA9IHNrYl9wdXQoc2tiLCB3ay0+aWVfbGVuKTsKIAkJbWVtY3B5KHBv cywgd2stPmllLCB3ay0+aWVfbGVuKTsKIAl9CiAKKwlpZiAod2stPmFzc29jLnVzZV8xMW4gJiYg d2stPmFzc29jLndtbV91c2VkICYmCisJICAgIGxvY2FsLT5ody5xdWV1ZXMgPj0gNCkKKwkJaWVl ZTgwMjExX2FkZF9odF9pZShza2IsIHdrLT5hc3NvYy5odF9pbmZvcm1hdGlvbl9pZSwKKwkJCQkg ICAgc2JhbmQsIHdrLT5jaGFuLCB3ay0+YXNzb2Muc21wcyk7CisKIAlpZiAod2stPmFzc29jLndt bV91c2VkICYmIGxvY2FsLT5ody5xdWV1ZXMgPj0gNCkgewogCQlwb3MgPSBza2JfcHV0KHNrYiwg OSk7CiAJCSpwb3MrKyA9IFdMQU5fRUlEX1ZFTkRPUl9TUEVDSUZJQzsKQEAgLTI1Miw5OCArMzY1 LDYgQEAgc3RhdGljIHZvaWQgaWVlZTgwMjExX3NlbmRfYXNzb2Moc3RydWN0IAogCQkqcG9zKysg PSAwOwogCX0KIAotCS8qIHdtbSBzdXBwb3J0IGlzIGEgbXVzdCB0byBIVCAqLwotCS8qCi0JICog SUVFRTgwMi4xMW4gZG9lcyBub3QgYWxsb3cgVEtJUC9XRVAgYXMgcGFpcndpc2UKLQkgKiBjaXBo ZXJzIGluIEhUIG1vZGUuIFdlIHN0aWxsIGFzc29jaWF0ZSBpbiBub24taHQKLQkgKiBtb2RlICgx MWEvYi9nKSBpZiBhbnkgb25lIG9mIHRoZXNlIGNpcGhlcnMgaXMKLQkgKiBjb25maWd1cmVkIGFz IHBhaXJ3aXNlLgotCSAqLwotCWlmICh3ay0+YXNzb2MudXNlXzExbiAmJiB3ay0+YXNzb2Mud21t X3VzZWQgJiYKLQkgICAgKGxvY2FsLT5ody5xdWV1ZXMgPj0gNCkgJiYKLQkgICAgc2JhbmQtPmh0 X2NhcC5odF9zdXBwb3J0ZWQgJiYKLQkgICAgKGh0X2llID0gd2stPmFzc29jLmh0X2luZm9ybWF0 aW9uX2llKSAmJgotCSAgICBodF9pZVsxXSA+PSBzaXplb2Yoc3RydWN0IGllZWU4MDIxMV9odF9p bmZvKSkgewotCQlzdHJ1Y3QgaWVlZTgwMjExX2h0X2luZm8gKmh0X2luZm8gPQotCQkJKHN0cnVj dCBpZWVlODAyMTFfaHRfaW5mbyAqKShodF9pZSArIDIpOwotCQl1MTYgY2FwID0gc2JhbmQtPmh0 X2NhcC5jYXA7Ci0JCV9fbGUxNiB0bXA7Ci0JCXUzMiBmbGFncyA9IGxvY2FsLT5ody5jb25mLmNo YW5uZWwtPmZsYWdzOwotCi0JCS8qIGRldGVybWluZSBjYXBhYmlsaXR5IGZsYWdzICovCi0KLQkJ aWYgKGllZWU4MDIxMV9kaXNhYmxlXzQwbWh6XzI0Z2h6ICYmCi0JCSAgICBzYmFuZC0+YmFuZCA9 PSBJRUVFODAyMTFfQkFORF8yR0haKSB7Ci0JCQljYXAgJj0gfklFRUU4MDIxMV9IVF9DQVBfU1VQ X1dJRFRIXzIwXzQwOwotCQkJY2FwICY9IH5JRUVFODAyMTFfSFRfQ0FQX1NHSV80MDsKLQkJfQot Ci0JCXN3aXRjaCAoaHRfaW5mby0+aHRfcGFyYW0gJiBJRUVFODAyMTFfSFRfUEFSQU1fQ0hBX1NF Q19PRkZTRVQpIHsKLQkJY2FzZSBJRUVFODAyMTFfSFRfUEFSQU1fQ0hBX1NFQ19BQk9WRToKLQkJ CWlmIChmbGFncyAmIElFRUU4MDIxMV9DSEFOX05PX0hUNDBQTFVTKSB7Ci0JCQkJY2FwICY9IH5J RUVFODAyMTFfSFRfQ0FQX1NVUF9XSURUSF8yMF80MDsKLQkJCQljYXAgJj0gfklFRUU4MDIxMV9I VF9DQVBfU0dJXzQwOwotCQkJfQotCQkJYnJlYWs7Ci0JCWNhc2UgSUVFRTgwMjExX0hUX1BBUkFN X0NIQV9TRUNfQkVMT1c6Ci0JCQlpZiAoZmxhZ3MgJiBJRUVFODAyMTFfQ0hBTl9OT19IVDQwTUlO VVMpIHsKLQkJCQljYXAgJj0gfklFRUU4MDIxMV9IVF9DQVBfU1VQX1dJRFRIXzIwXzQwOwotCQkJ CWNhcCAmPSB+SUVFRTgwMjExX0hUX0NBUF9TR0lfNDA7Ci0JCQl9Ci0JCQlicmVhazsKLQkJfQot Ci0JCS8qIHNldCBTTSBQUyBtb2RlIHByb3Blcmx5ICovCi0JCWNhcCAmPSB+SUVFRTgwMjExX0hU X0NBUF9TTV9QUzsKLQkJc3dpdGNoICh3ay0+YXNzb2Muc21wcykgewotCQljYXNlIElFRUU4MDIx MV9TTVBTX0FVVE9NQVRJQzoKLQkJY2FzZSBJRUVFODAyMTFfU01QU19OVU1fTU9ERVM6Ci0JCQlX QVJOX09OKDEpOwotCQljYXNlIElFRUU4MDIxMV9TTVBTX09GRjoKLQkJCWNhcCB8PSBXTEFOX0hU X0NBUF9TTV9QU19ESVNBQkxFRCA8PAotCQkJCUlFRUU4MDIxMV9IVF9DQVBfU01fUFNfU0hJRlQ7 Ci0JCQlicmVhazsKLQkJY2FzZSBJRUVFODAyMTFfU01QU19TVEFUSUM6Ci0JCQljYXAgfD0gV0xB Tl9IVF9DQVBfU01fUFNfU1RBVElDIDw8Ci0JCQkJSUVFRTgwMjExX0hUX0NBUF9TTV9QU19TSElG VDsKLQkJCWJyZWFrOwotCQljYXNlIElFRUU4MDIxMV9TTVBTX0RZTkFNSUM6Ci0JCQljYXAgfD0g V0xBTl9IVF9DQVBfU01fUFNfRFlOQU1JQyA8PAotCQkJCUlFRUU4MDIxMV9IVF9DQVBfU01fUFNf U0hJRlQ7Ci0JCQlicmVhazsKLQkJfQotCi0JCS8qIHJlc2VydmUgYW5kIGZpbGwgSUUgKi8KLQot CQlwb3MgPSBza2JfcHV0KHNrYiwgc2l6ZW9mKHN0cnVjdCBpZWVlODAyMTFfaHRfY2FwKSArIDIp OwotCQkqcG9zKysgPSBXTEFOX0VJRF9IVF9DQVBBQklMSVRZOwotCQkqcG9zKysgPSBzaXplb2Yo c3RydWN0IGllZWU4MDIxMV9odF9jYXApOwotCQltZW1zZXQocG9zLCAwLCBzaXplb2Yoc3RydWN0 IGllZWU4MDIxMV9odF9jYXApKTsKLQotCQkvKiBjYXBhYmlsaXR5IGZsYWdzICovCi0JCXRtcCA9 IGNwdV90b19sZTE2KGNhcCk7Ci0JCW1lbWNweShwb3MsICZ0bXAsIHNpemVvZih1MTYpKTsKLQkJ cG9zICs9IHNpemVvZih1MTYpOwotCi0JCS8qIEFNUERVIHBhcmFtZXRlcnMgKi8KLQkJKnBvcysr ID0gc2JhbmQtPmh0X2NhcC5hbXBkdV9mYWN0b3IgfAotCQkJIChzYmFuZC0+aHRfY2FwLmFtcGR1 X2RlbnNpdHkgPDwKLQkJCSAJSUVFRTgwMjExX0hUX0FNUERVX1BBUk1fREVOU0lUWV9TSElGVCk7 Ci0KLQkJLyogTUNTIHNldCAqLwotCQltZW1jcHkocG9zLCAmc2JhbmQtPmh0X2NhcC5tY3MsIHNp emVvZihzYmFuZC0+aHRfY2FwLm1jcykpOwotCQlwb3MgKz0gc2l6ZW9mKHNiYW5kLT5odF9jYXAu bWNzKTsKLQotCQkvKiBleHRlbmRlZCBjYXBhYmlsaXRpZXMgKi8KLQkJcG9zICs9IHNpemVvZihf X2xlMTYpOwotCi0JCS8qIEJGIGNhcGFiaWxpdGllcyAqLwotCQlwb3MgKz0gc2l6ZW9mKF9fbGUz Mik7Ci0KLQkJLyogYW50ZW5uYSBzZWxlY3Rpb24gKi8KLQkJcG9zICs9IHNpemVvZih1OCk7Ci0J fQotCiAJSUVFRTgwMjExX1NLQl9DQihza2IpLT5mbGFncyB8PSBJRUVFODAyMTFfVFhfSU5URkxf RE9OVF9FTkNSWVBUOwogCWllZWU4MDIxMV90eF9za2Ioc2RhdGEsIHNrYik7CiB9Ci0tLSB3aXJl bGVzcy10ZXN0aW5nLm9yaWcvbmV0L21hYzgwMjExL21sbWUuYwkyMDA5LTEyLTAzIDE2OjQwOjU5 LjAwMDAwMDAwMCArMDEwMAorKysgd2lyZWxlc3MtdGVzdGluZy9uZXQvbWFjODAyMTEvbWxtZS5j CTIwMDktMTItMDMgMTY6NDE6NDUuMDAwMDAwMDAwICswMTAwCkBAIC0xODc2LDYgKzE4NzYsMTMg QEAgaW50IGllZWU4MDIxMV9tZ2RfYXNzb2Moc3RydWN0IGllZWU4MDIxMQogCQlpZm1nZC0+YXBf c21wcyA9IGlmbWdkLT5yZXFfc21wczsKIAogCXdrLT5hc3NvYy5zbXBzID0gaWZtZ2QtPmFwX3Nt cHM7CisJLyoKKwkgKiBJRUVFODAyLjExbiBkb2VzIG5vdCBhbGxvdyBUS0lQL1dFUCBhcyBwYWly d2lzZSBjaXBoZXJzIGluIEhUIG1vZGUuCisJICogV2Ugc3RpbGwgYXNzb2NpYXRlIGluIG5vbi1I VCBtb2RlICgxMWEvYi9nKSBpZiBhbnkgb25lIG9mIHRoZXNlCisJICogY2lwaGVycyBpcyBjb25m aWd1cmVkIGFzIHBhaXJ3aXNlLgorCSAqIFdlIGNhbiBzZXQgdGhpcyB0byB0cnVlIGZvciBub24t MTFuIGhhcmR3YXJlLCB0aGF0J2xsIGJlIGNoZWNrZWQKKwkgKiBzZXBhcmF0ZWx5IGFsb25nIHdp dGggdGhlIHBlZXIgY2FwYWJpbGl0aWVzLgorCSAqLwogCXdrLT5hc3NvYy51c2VfMTFuID0gIShp Zm1nZC0+ZmxhZ3MgJiBJRUVFODAyMTFfU1RBX0RJU0FCTEVfMTFOKTsKIAl3ay0+YXNzb2MuY2Fw YWJpbGl0eSA9IHJlcS0+YnNzLT5jYXBhYmlsaXR5OwogCXdrLT5hc3NvYy53bW1fdXNlZCA9IHdr LT5hc3NvYy5ic3MtPndtbV91c2VkOwoKCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQpJbnRlbCBFbGVjdHJvbmljcyBM dGQuCgpUaGlzIGUtbWFpbCBhbmQgYW55IGF0dGFjaG1lbnRzIG1heSBjb250YWluIGNvbmZpZGVu dGlhbCBtYXRlcmlhbCBmb3IKdGhlIHNvbGUgdXNlIG9mIHRoZSBpbnRlbmRlZCByZWNpcGllbnQo cykuIEFueSByZXZpZXcgb3IgZGlzdHJpYnV0aW9uCmJ5IG90aGVycyBpcyBzdHJpY3RseSBwcm9o aWJpdGVkLiBJZiB5b3UgYXJlIG5vdCB0aGUgaW50ZW5kZWQKcmVjaXBpZW50LCBwbGVhc2UgY29u dGFjdCB0aGUgc2VuZGVyIGFuZCBkZWxldGUgYWxsIGNvcGllcy4K ^ permalink raw reply [flat|nested] 2+ messages in thread
* [PATCH v2] mac80211: refactor association 2009-12-03 19:41 [PATCH] mac80211: refactor association Johannes Berg @ 2009-12-04 7:52 ` Johannes Berg 0 siblings, 0 replies; 2+ messages in thread From: Johannes Berg @ 2009-12-04 7:52 UTC (permalink / raw) To: John Linville; +Cc: linux-wireless Refactor the code to reserve an skb of the right size (instead of hoping 200 bytes are enough forever), and also put HT IE generation into an own function. Additionally, put the HT IE before the vendor-specific WMM IE. This still leaves things not quite ordered correctly, due to user-specified IEs, add a note about that for now. Signed-off-by: Johannes Berg <johannes@sipsolutions.net> --- Eep. So Luis told me but I thought it was another patch -- this one sure shouldn't go out with @intel. net/mac80211/mlme.c | 7 + net/mac80211/work.c | 239 ++++++++++++++++++++++++++++------------------------ 2 files changed, 137 insertions(+), 109 deletions(-) --- wireless-testing.orig/net/mac80211/work.c 2009-12-03 16:28:20.000000000 +0100 +++ wireless-testing/net/mac80211/work.c 2009-12-03 20:33:20.000000000 +0100 @@ -100,6 +100,102 @@ static int ieee80211_compatible_rates(co /* frame sending functions */ +static void ieee80211_add_ht_ie(struct sk_buff *skb, const u8 *ht_info_ie, + struct ieee80211_supported_band *sband, + struct ieee80211_channel *channel, + enum ieee80211_smps_mode smps) +{ + struct ieee80211_ht_info *ht_info; + u8 *pos; + u32 flags = channel->flags; + u16 cap = sband->ht_cap.cap; + __le16 tmp; + + if (!sband->ht_cap.ht_supported) + return; + + if (!ht_info_ie) + return; + + if (ht_info_ie[1] < sizeof(struct ieee80211_ht_info)) + return; + + ht_info = (struct ieee80211_ht_info *)(ht_info_ie + 2); + + /* determine capability flags */ + + if (ieee80211_disable_40mhz_24ghz && + sband->band == IEEE80211_BAND_2GHZ) { + cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; + cap &= ~IEEE80211_HT_CAP_SGI_40; + } + + switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { + case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: + if (flags & IEEE80211_CHAN_NO_HT40PLUS) { + cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; + cap &= ~IEEE80211_HT_CAP_SGI_40; + } + break; + case IEEE80211_HT_PARAM_CHA_SEC_BELOW: + if (flags & IEEE80211_CHAN_NO_HT40MINUS) { + cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; + cap &= ~IEEE80211_HT_CAP_SGI_40; + } + break; + } + + /* set SM PS mode properly */ + cap &= ~IEEE80211_HT_CAP_SM_PS; + switch (smps) { + case IEEE80211_SMPS_AUTOMATIC: + case IEEE80211_SMPS_NUM_MODES: + WARN_ON(1); + case IEEE80211_SMPS_OFF: + cap |= WLAN_HT_CAP_SM_PS_DISABLED << + IEEE80211_HT_CAP_SM_PS_SHIFT; + break; + case IEEE80211_SMPS_STATIC: + cap |= WLAN_HT_CAP_SM_PS_STATIC << + IEEE80211_HT_CAP_SM_PS_SHIFT; + break; + case IEEE80211_SMPS_DYNAMIC: + cap |= WLAN_HT_CAP_SM_PS_DYNAMIC << + IEEE80211_HT_CAP_SM_PS_SHIFT; + break; + } + + /* reserve and fill IE */ + + pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2); + *pos++ = WLAN_EID_HT_CAPABILITY; + *pos++ = sizeof(struct ieee80211_ht_cap); + memset(pos, 0, sizeof(struct ieee80211_ht_cap)); + + /* capability flags */ + tmp = cpu_to_le16(cap); + memcpy(pos, &tmp, sizeof(u16)); + pos += sizeof(u16); + + /* AMPDU parameters */ + *pos++ = sband->ht_cap.ampdu_factor | + (sband->ht_cap.ampdu_density << + IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); + + /* MCS set */ + memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); + pos += sizeof(sband->ht_cap.mcs); + + /* extended capabilities */ + pos += sizeof(__le16); + + /* BF capabilities */ + pos += sizeof(__le32); + + /* antenna selection */ + pos += sizeof(u8); +} + static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata, struct ieee80211_work *wk) { @@ -107,15 +203,34 @@ static void ieee80211_send_assoc(struct struct sk_buff *skb; struct ieee80211_mgmt *mgmt; u8 *pos; - const u8 *ies, *ht_ie; + const u8 *ies; int i, len, count, rates_len, supp_rates_len; u16 capab; struct ieee80211_supported_band *sband; u32 rates = 0; - skb = dev_alloc_skb(local->hw.extra_tx_headroom + - sizeof(*mgmt) + 200 + wk->ie_len + - wk->assoc.ssid_len); + sband = local->hw.wiphy->bands[wk->chan->band]; + + /* + * Get all rates supported by the device and the AP as + * some APs don't like getting a superset of their rates + * in the association request (e.g. D-Link DAP 1353 in + * b-only mode)... + */ + rates_len = ieee80211_compatible_rates(wk->assoc.supp_rates, + wk->assoc.supp_rates_len, + sband, &rates); + + skb = alloc_skb(local->hw.extra_tx_headroom + + sizeof(*mgmt) + /* bit too much but doesn't matter */ + 2 + wk->assoc.ssid_len + /* SSID */ + 4 + rates_len + /* (extended) rates */ + 4 + /* power capability */ + 2 + 2 * sband->n_channels + /* supported channels */ + 2 + sizeof(struct ieee80211_ht_cap) + /* HT */ + wk->ie_len + /* extra IEs */ + 9, /* WMM */ + GFP_KERNEL); if (!skb) { printk(KERN_DEBUG "%s: failed to allocate buffer for assoc " "frame\n", sdata->name); @@ -123,8 +238,6 @@ static void ieee80211_send_assoc(struct } skb_reserve(skb, local->hw.extra_tx_headroom); - sband = local->hw.wiphy->bands[wk->chan->band]; - capab = WLAN_CAPABILITY_ESS; if (sband->band == IEEE80211_BAND_2GHZ) { @@ -137,16 +250,6 @@ static void ieee80211_send_assoc(struct if (wk->assoc.capability & WLAN_CAPABILITY_PRIVACY) capab |= WLAN_CAPABILITY_PRIVACY; - /* - * Get all rates supported by the device and the AP as - * some APs don't like getting a superset of their rates - * in the association request (e.g. D-Link DAP 1353 in - * b-only mode)... - */ - rates_len = ieee80211_compatible_rates(wk->assoc.supp_rates, - wk->assoc.supp_rates_len, - sband, &rates); - if ((wk->assoc.capability & WLAN_CAPABILITY_SPECTRUM_MGMT) && (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT)) capab |= WLAN_CAPABILITY_SPECTRUM_MGMT; @@ -220,7 +323,7 @@ static void ieee80211_send_assoc(struct *pos++ = WLAN_EID_PWR_CAPABILITY; *pos++ = 2; *pos++ = 0; /* min tx power */ - *pos++ = local->hw.conf.channel->max_power; /* max tx power */ + *pos++ = wk->chan->max_power; /* max tx power */ /* 2. supported channels */ /* TODO: get this in reg domain format */ @@ -234,11 +337,21 @@ static void ieee80211_send_assoc(struct } } + /* + * XXX: These IEs could contain (vendor-specified) + * IEs that belong after HT -- the buffer may + * need to be split up. + */ if (wk->ie_len && wk->ie) { pos = skb_put(skb, wk->ie_len); memcpy(pos, wk->ie, wk->ie_len); } + if (wk->assoc.use_11n && wk->assoc.wmm_used && + local->hw.queues >= 4) + ieee80211_add_ht_ie(skb, wk->assoc.ht_information_ie, + sband, wk->chan, wk->assoc.smps); + if (wk->assoc.wmm_used && local->hw.queues >= 4) { pos = skb_put(skb, 9); *pos++ = WLAN_EID_VENDOR_SPECIFIC; @@ -252,98 +365,6 @@ static void ieee80211_send_assoc(struct *pos++ = 0; } - /* wmm support is a must to HT */ - /* - * IEEE802.11n does not allow TKIP/WEP as pairwise - * ciphers in HT mode. We still associate in non-ht - * mode (11a/b/g) if any one of these ciphers is - * configured as pairwise. - */ - if (wk->assoc.use_11n && wk->assoc.wmm_used && - (local->hw.queues >= 4) && - sband->ht_cap.ht_supported && - (ht_ie = wk->assoc.ht_information_ie) && - ht_ie[1] >= sizeof(struct ieee80211_ht_info)) { - struct ieee80211_ht_info *ht_info = - (struct ieee80211_ht_info *)(ht_ie + 2); - u16 cap = sband->ht_cap.cap; - __le16 tmp; - u32 flags = local->hw.conf.channel->flags; - - /* determine capability flags */ - - if (ieee80211_disable_40mhz_24ghz && - sband->band == IEEE80211_BAND_2GHZ) { - cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; - cap &= ~IEEE80211_HT_CAP_SGI_40; - } - - switch (ht_info->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) { - case IEEE80211_HT_PARAM_CHA_SEC_ABOVE: - if (flags & IEEE80211_CHAN_NO_HT40PLUS) { - cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; - cap &= ~IEEE80211_HT_CAP_SGI_40; - } - break; - case IEEE80211_HT_PARAM_CHA_SEC_BELOW: - if (flags & IEEE80211_CHAN_NO_HT40MINUS) { - cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40; - cap &= ~IEEE80211_HT_CAP_SGI_40; - } - break; - } - - /* set SM PS mode properly */ - cap &= ~IEEE80211_HT_CAP_SM_PS; - switch (wk->assoc.smps) { - case IEEE80211_SMPS_AUTOMATIC: - case IEEE80211_SMPS_NUM_MODES: - WARN_ON(1); - case IEEE80211_SMPS_OFF: - cap |= WLAN_HT_CAP_SM_PS_DISABLED << - IEEE80211_HT_CAP_SM_PS_SHIFT; - break; - case IEEE80211_SMPS_STATIC: - cap |= WLAN_HT_CAP_SM_PS_STATIC << - IEEE80211_HT_CAP_SM_PS_SHIFT; - break; - case IEEE80211_SMPS_DYNAMIC: - cap |= WLAN_HT_CAP_SM_PS_DYNAMIC << - IEEE80211_HT_CAP_SM_PS_SHIFT; - break; - } - - /* reserve and fill IE */ - - pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2); - *pos++ = WLAN_EID_HT_CAPABILITY; - *pos++ = sizeof(struct ieee80211_ht_cap); - memset(pos, 0, sizeof(struct ieee80211_ht_cap)); - - /* capability flags */ - tmp = cpu_to_le16(cap); - memcpy(pos, &tmp, sizeof(u16)); - pos += sizeof(u16); - - /* AMPDU parameters */ - *pos++ = sband->ht_cap.ampdu_factor | - (sband->ht_cap.ampdu_density << - IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT); - - /* MCS set */ - memcpy(pos, &sband->ht_cap.mcs, sizeof(sband->ht_cap.mcs)); - pos += sizeof(sband->ht_cap.mcs); - - /* extended capabilities */ - pos += sizeof(__le16); - - /* BF capabilities */ - pos += sizeof(__le32); - - /* antenna selection */ - pos += sizeof(u8); - } - IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT; ieee80211_tx_skb(sdata, skb); } --- wireless-testing.orig/net/mac80211/mlme.c 2009-12-03 16:40:59.000000000 +0100 +++ wireless-testing/net/mac80211/mlme.c 2009-12-03 16:41:45.000000000 +0100 @@ -1876,6 +1876,13 @@ int ieee80211_mgd_assoc(struct ieee80211 ifmgd->ap_smps = ifmgd->req_smps; wk->assoc.smps = ifmgd->ap_smps; + /* + * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode. + * We still associate in non-HT mode (11a/b/g) if any one of these + * ciphers is configured as pairwise. + * We can set this to true for non-11n hardware, that'll be checked + * separately along with the peer capabilities. + */ wk->assoc.use_11n = !(ifmgd->flags & IEEE80211_STA_DISABLE_11N); wk->assoc.capability = req->bss->capability; wk->assoc.wmm_used = wk->assoc.bss->wmm_used; ^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2009-12-04 7:53 UTC | newest] Thread overview: 2+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2009-12-03 19:41 [PATCH] mac80211: refactor association Johannes Berg 2009-12-04 7:52 ` [PATCH v2] " Johannes Berg
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox