p2p_supplicant.c 145 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839484048414842484348444845484648474848484948504851485248534854485548564857485848594860486148624863486448654866486748684869487048714872487348744875487648774878487948804881488248834884488548864887488848894890489148924893489448954896489748984899490049014902490349044905490649074908490949104911491249134914491549164917491849194920492149224923492449254926492749284929493049314932493349344935493649374938493949404941494249434944494549464947494849494950495149524953495449554956495749584959496049614962496349644965496649674968496949704971497249734974497549764977497849794980498149824983498449854986498749884989499049914992499349944995499649974998499950005001500250035004500550065007500850095010501150125013501450155016501750185019502050215022502350245025502650275028502950305031503250335034503550365037503850395040504150425043504450455046504750485049505050515052505350545055505650575058505950605061506250635064506550665067506850695070507150725073507450755076507750785079508050815082508350845085508650875088508950905091509250935094509550965097509850995100510151025103510451055106510751085109511051115112511351145115511651175118511951205121512251235124512551265127512851295130513151325133513451355136513751385139514051415142514351445145514651475148514951505151515251535154515551565157515851595160516151625163516451655166516751685169517051715172517351745175517651775178517951805181518251835184518551865187518851895190519151925193519451955196519751985199520052015202520352045205520652075208520952105211521252135214521552165217521852195220522152225223522452255226522752285229523052315232523352345235523652375238523952405241524252435244524552465247524852495250525152525253525452555256525752585259526052615262526352645265526652675268526952705271527252735274527552765277527852795280
  1. /*
  2. * wpa_supplicant - P2P
  3. * Copyright (c) 2009-2010, Atheros Communications
  4. *
  5. * This software may be distributed under the terms of the BSD license.
  6. * See README for more details.
  7. */
  8. #include "includes.h"
  9. #include "common.h"
  10. #include "eloop.h"
  11. #include "common/ieee802_11_common.h"
  12. #include "common/ieee802_11_defs.h"
  13. #include "common/wpa_ctrl.h"
  14. #include "wps/wps_i.h"
  15. #include "p2p/p2p.h"
  16. #include "ap/hostapd.h"
  17. #include "ap/ap_config.h"
  18. #include "ap/p2p_hostapd.h"
  19. #include "eapol_supp/eapol_supp_sm.h"
  20. #include "rsn_supp/wpa.h"
  21. #include "wpa_supplicant_i.h"
  22. #include "driver_i.h"
  23. #include "ap.h"
  24. #include "config_ssid.h"
  25. #include "config.h"
  26. #include "notify.h"
  27. #include "scan.h"
  28. #include "bss.h"
  29. #include "offchannel.h"
  30. #include "wps_supplicant.h"
  31. #include "p2p_supplicant.h"
  32. /*
  33. * How many times to try to scan to find the GO before giving up on join
  34. * request.
  35. */
  36. #define P2P_MAX_JOIN_SCAN_ATTEMPTS 10
  37. #define P2P_AUTO_PD_SCAN_ATTEMPTS 5
  38. #ifndef P2P_MAX_CLIENT_IDLE
  39. /*
  40. * How many seconds to try to reconnect to the GO when connection in P2P client
  41. * role has been lost.
  42. */
  43. #define P2P_MAX_CLIENT_IDLE 10
  44. #endif /* P2P_MAX_CLIENT_IDLE */
  45. #ifndef P2P_MAX_INITIAL_CONN_WAIT
  46. /*
  47. * How many seconds to wait for initial 4-way handshake to get completed after
  48. * WPS provisioning step.
  49. */
  50. #define P2P_MAX_INITIAL_CONN_WAIT 10
  51. #endif /* P2P_MAX_INITIAL_CONN_WAIT */
  52. #ifndef P2P_CONCURRENT_SEARCH_DELAY
  53. #define P2P_CONCURRENT_SEARCH_DELAY 500
  54. #endif /* P2P_CONCURRENT_SEARCH_DELAY */
  55. enum p2p_group_removal_reason {
  56. P2P_GROUP_REMOVAL_UNKNOWN,
  57. P2P_GROUP_REMOVAL_SILENT,
  58. P2P_GROUP_REMOVAL_FORMATION_FAILED,
  59. P2P_GROUP_REMOVAL_REQUESTED,
  60. P2P_GROUP_REMOVAL_IDLE_TIMEOUT,
  61. P2P_GROUP_REMOVAL_UNAVAILABLE,
  62. P2P_GROUP_REMOVAL_GO_ENDING_SESSION
  63. };
  64. static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx);
  65. static struct wpa_supplicant *
  66. wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
  67. int go);
  68. static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s);
  69. static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq);
  70. static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx);
  71. static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
  72. const u8 *dev_addr, enum p2p_wps_method wps_method,
  73. int auto_join);
  74. static void wpas_p2p_pd_before_join_timeout(void *eloop_ctx,
  75. void *timeout_ctx);
  76. static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s);
  77. static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s);
  78. static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx);
  79. static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s);
  80. static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
  81. int group_added);
  82. static void wpas_p2p_scan_res_handler(struct wpa_supplicant *wpa_s,
  83. struct wpa_scan_results *scan_res)
  84. {
  85. size_t i;
  86. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  87. return;
  88. wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS)",
  89. (int) scan_res->num);
  90. for (i = 0; i < scan_res->num; i++) {
  91. struct wpa_scan_res *bss = scan_res->res[i];
  92. if (p2p_scan_res_handler(wpa_s->global->p2p, bss->bssid,
  93. bss->freq, bss->level,
  94. (const u8 *) (bss + 1),
  95. bss->ie_len) > 0)
  96. break;
  97. }
  98. p2p_scan_res_handled(wpa_s->global->p2p);
  99. }
  100. static int wpas_p2p_scan(void *ctx, enum p2p_scan_type type, int freq,
  101. unsigned int num_req_dev_types,
  102. const u8 *req_dev_types, const u8 *dev_id, u16 pw_id)
  103. {
  104. struct wpa_supplicant *wpa_s = ctx;
  105. struct wpa_supplicant *ifs;
  106. struct wpa_driver_scan_params params;
  107. int ret;
  108. struct wpabuf *wps_ie, *ies;
  109. int social_channels[] = { 2412, 2437, 2462, 0, 0 };
  110. size_t ielen;
  111. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  112. return -1;
  113. for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
  114. if (ifs->sta_scan_pending &&
  115. wpas_p2p_in_progress(wpa_s) == 2) {
  116. wpa_printf(MSG_DEBUG, "Delaying P2P scan to allow "
  117. "pending station mode scan to be "
  118. "completed on interface %s", ifs->ifname);
  119. wpa_s->global->p2p_cb_on_scan_complete = 1;
  120. wpa_supplicant_req_scan(ifs, 0, 0);
  121. return 1;
  122. }
  123. }
  124. os_memset(&params, 0, sizeof(params));
  125. /* P2P Wildcard SSID */
  126. params.num_ssids = 1;
  127. params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
  128. params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
  129. wpa_s->wps->dev.p2p = 1;
  130. wps_ie = wps_build_probe_req_ie(pw_id, &wpa_s->wps->dev,
  131. wpa_s->wps->uuid, WPS_REQ_ENROLLEE,
  132. num_req_dev_types, req_dev_types);
  133. if (wps_ie == NULL)
  134. return -1;
  135. ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
  136. ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen);
  137. if (ies == NULL) {
  138. wpabuf_free(wps_ie);
  139. return -1;
  140. }
  141. wpabuf_put_buf(ies, wps_ie);
  142. wpabuf_free(wps_ie);
  143. p2p_scan_ie(wpa_s->global->p2p, ies, dev_id);
  144. params.p2p_probe = 1;
  145. params.extra_ies = wpabuf_head(ies);
  146. params.extra_ies_len = wpabuf_len(ies);
  147. switch (type) {
  148. case P2P_SCAN_SOCIAL:
  149. params.freqs = social_channels;
  150. break;
  151. case P2P_SCAN_FULL:
  152. break;
  153. case P2P_SCAN_SOCIAL_PLUS_ONE:
  154. social_channels[3] = freq;
  155. params.freqs = social_channels;
  156. break;
  157. }
  158. ret = wpa_drv_scan(wpa_s, &params);
  159. wpabuf_free(ies);
  160. if (ret) {
  161. for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
  162. if (ifs->scanning ||
  163. ifs->scan_res_handler == wpas_p2p_scan_res_handler) {
  164. wpa_s->global->p2p_cb_on_scan_complete = 1;
  165. ret = 1;
  166. break;
  167. }
  168. }
  169. } else
  170. wpa_s->scan_res_handler = wpas_p2p_scan_res_handler;
  171. return ret;
  172. }
  173. static enum wpa_driver_if_type wpas_p2p_if_type(int p2p_group_interface)
  174. {
  175. switch (p2p_group_interface) {
  176. case P2P_GROUP_INTERFACE_PENDING:
  177. return WPA_IF_P2P_GROUP;
  178. case P2P_GROUP_INTERFACE_GO:
  179. return WPA_IF_P2P_GO;
  180. case P2P_GROUP_INTERFACE_CLIENT:
  181. return WPA_IF_P2P_CLIENT;
  182. }
  183. return WPA_IF_P2P_GROUP;
  184. }
  185. static struct wpa_supplicant * wpas_get_p2p_group(struct wpa_supplicant *wpa_s,
  186. const u8 *ssid,
  187. size_t ssid_len, int *go)
  188. {
  189. struct wpa_ssid *s;
  190. for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  191. for (s = wpa_s->conf->ssid; s; s = s->next) {
  192. if (s->disabled != 0 || !s->p2p_group ||
  193. s->ssid_len != ssid_len ||
  194. os_memcmp(ssid, s->ssid, ssid_len) != 0)
  195. continue;
  196. if (s->mode == WPAS_MODE_P2P_GO &&
  197. s != wpa_s->current_ssid)
  198. continue;
  199. if (go)
  200. *go = s->mode == WPAS_MODE_P2P_GO;
  201. return wpa_s;
  202. }
  203. }
  204. return NULL;
  205. }
  206. static int wpas_p2p_group_delete(struct wpa_supplicant *wpa_s,
  207. enum p2p_group_removal_reason removal_reason)
  208. {
  209. struct wpa_ssid *ssid;
  210. char *gtype;
  211. const char *reason;
  212. ssid = wpa_s->current_ssid;
  213. if (ssid == NULL) {
  214. /*
  215. * The current SSID was not known, but there may still be a
  216. * pending P2P group interface waiting for provisioning or a
  217. * P2P group that is trying to reconnect.
  218. */
  219. ssid = wpa_s->conf->ssid;
  220. while (ssid) {
  221. if (ssid->p2p_group && ssid->disabled != 2)
  222. break;
  223. ssid = ssid->next;
  224. }
  225. if (ssid == NULL &&
  226. wpa_s->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)
  227. {
  228. wpa_printf(MSG_ERROR, "P2P: P2P group interface "
  229. "not found");
  230. return -1;
  231. }
  232. }
  233. if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_GO)
  234. gtype = "GO";
  235. else if (wpa_s->p2p_group_interface == P2P_GROUP_INTERFACE_CLIENT ||
  236. (ssid && ssid->mode == WPAS_MODE_INFRA)) {
  237. wpa_s->reassociate = 0;
  238. wpa_s->disconnected = 1;
  239. wpa_supplicant_deauthenticate(wpa_s,
  240. WLAN_REASON_DEAUTH_LEAVING);
  241. gtype = "client";
  242. } else
  243. gtype = "GO";
  244. if (wpa_s->cross_connect_in_use) {
  245. wpa_s->cross_connect_in_use = 0;
  246. wpa_msg(wpa_s->parent, MSG_INFO,
  247. P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
  248. wpa_s->ifname, wpa_s->cross_connect_uplink);
  249. }
  250. switch (removal_reason) {
  251. case P2P_GROUP_REMOVAL_REQUESTED:
  252. reason = " reason=REQUESTED";
  253. break;
  254. case P2P_GROUP_REMOVAL_FORMATION_FAILED:
  255. reason = " reason=FORMATION_FAILED";
  256. break;
  257. case P2P_GROUP_REMOVAL_IDLE_TIMEOUT:
  258. reason = " reason=IDLE";
  259. break;
  260. case P2P_GROUP_REMOVAL_UNAVAILABLE:
  261. reason = " reason=UNAVAILABLE";
  262. break;
  263. case P2P_GROUP_REMOVAL_GO_ENDING_SESSION:
  264. reason = " reason=GO_ENDING_SESSION";
  265. break;
  266. default:
  267. reason = "";
  268. break;
  269. }
  270. if (removal_reason != P2P_GROUP_REMOVAL_SILENT) {
  271. wpa_msg(wpa_s->parent, MSG_INFO,
  272. P2P_EVENT_GROUP_REMOVED "%s %s%s",
  273. wpa_s->ifname, gtype, reason);
  274. }
  275. if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
  276. wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
  277. if (removal_reason != P2P_GROUP_REMOVAL_SILENT && ssid)
  278. wpas_notify_p2p_group_removed(wpa_s, ssid, gtype);
  279. if (wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE) {
  280. struct wpa_global *global;
  281. char *ifname;
  282. enum wpa_driver_if_type type;
  283. wpa_printf(MSG_DEBUG, "P2P: Remove group interface %s",
  284. wpa_s->ifname);
  285. global = wpa_s->global;
  286. ifname = os_strdup(wpa_s->ifname);
  287. type = wpas_p2p_if_type(wpa_s->p2p_group_interface);
  288. wpa_supplicant_remove_iface(wpa_s->global, wpa_s, 0);
  289. wpa_s = global->ifaces;
  290. if (wpa_s && ifname)
  291. wpa_drv_if_remove(wpa_s, type, ifname);
  292. os_free(ifname);
  293. return 1;
  294. }
  295. wpa_printf(MSG_DEBUG, "P2P: Remove temporary group network");
  296. if (ssid && (ssid->p2p_group ||
  297. ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION ||
  298. (ssid->key_mgmt & WPA_KEY_MGMT_WPS))) {
  299. int id = ssid->id;
  300. if (ssid == wpa_s->current_ssid) {
  301. wpa_sm_set_config(wpa_s->wpa, NULL);
  302. eapol_sm_notify_config(wpa_s->eapol, NULL, NULL);
  303. wpa_s->current_ssid = NULL;
  304. }
  305. /*
  306. * Networks objects created during any P2P activities are not
  307. * exposed out as they might/will confuse certain non-P2P aware
  308. * applications since these network objects won't behave like
  309. * regular ones.
  310. *
  311. * Likewise, we don't send out network removed signals for such
  312. * network objects.
  313. */
  314. wpa_config_remove_network(wpa_s->conf, id);
  315. wpa_supplicant_clear_status(wpa_s);
  316. wpa_supplicant_cancel_sched_scan(wpa_s);
  317. wpa_s->sta_scan_pending = 0;
  318. } else {
  319. wpa_printf(MSG_DEBUG, "P2P: Temporary group network not "
  320. "found");
  321. }
  322. if (wpa_s->ap_iface)
  323. wpa_supplicant_ap_deinit(wpa_s);
  324. else
  325. wpa_drv_deinit_p2p_cli(wpa_s);
  326. return 0;
  327. }
  328. static int wpas_p2p_persistent_group(struct wpa_supplicant *wpa_s,
  329. u8 *go_dev_addr,
  330. const u8 *ssid, size_t ssid_len)
  331. {
  332. struct wpa_bss *bss;
  333. const u8 *bssid;
  334. struct wpabuf *p2p;
  335. u8 group_capab;
  336. const u8 *addr;
  337. if (wpa_s->go_params)
  338. bssid = wpa_s->go_params->peer_interface_addr;
  339. else
  340. bssid = wpa_s->bssid;
  341. bss = wpa_bss_get(wpa_s, bssid, ssid, ssid_len);
  342. if (bss == NULL) {
  343. u8 iface_addr[ETH_ALEN];
  344. if (p2p_get_interface_addr(wpa_s->global->p2p, bssid,
  345. iface_addr) == 0)
  346. bss = wpa_bss_get(wpa_s, iface_addr, ssid, ssid_len);
  347. }
  348. if (bss == NULL) {
  349. wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
  350. "group is persistent - BSS " MACSTR " not found",
  351. MAC2STR(bssid));
  352. return 0;
  353. }
  354. p2p = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
  355. if (p2p == NULL) {
  356. wpa_printf(MSG_DEBUG, "P2P: Could not figure out whether "
  357. "group is persistent - BSS " MACSTR
  358. " did not include P2P IE", MAC2STR(bssid));
  359. wpa_hexdump(MSG_DEBUG, "P2P: Probe Response IEs",
  360. (u8 *) (bss + 1), bss->ie_len);
  361. wpa_hexdump(MSG_DEBUG, "P2P: Beacon IEs",
  362. ((u8 *) bss + 1) + bss->ie_len,
  363. bss->beacon_ie_len);
  364. return 0;
  365. }
  366. group_capab = p2p_get_group_capab(p2p);
  367. addr = p2p_get_go_dev_addr(p2p);
  368. wpa_printf(MSG_DEBUG, "P2P: Checking whether group is persistent: "
  369. "group_capab=0x%x", group_capab);
  370. if (addr) {
  371. os_memcpy(go_dev_addr, addr, ETH_ALEN);
  372. wpa_printf(MSG_DEBUG, "P2P: GO Device Address " MACSTR,
  373. MAC2STR(addr));
  374. } else
  375. os_memset(go_dev_addr, 0, ETH_ALEN);
  376. wpabuf_free(p2p);
  377. wpa_printf(MSG_DEBUG, "P2P: BSS " MACSTR " group_capab=0x%x "
  378. "go_dev_addr=" MACSTR,
  379. MAC2STR(bssid), group_capab, MAC2STR(go_dev_addr));
  380. return group_capab & P2P_GROUP_CAPAB_PERSISTENT_GROUP;
  381. }
  382. static int wpas_p2p_store_persistent_group(struct wpa_supplicant *wpa_s,
  383. struct wpa_ssid *ssid,
  384. const u8 *go_dev_addr)
  385. {
  386. struct wpa_ssid *s;
  387. int changed = 0;
  388. wpa_printf(MSG_DEBUG, "P2P: Storing credentials for a persistent "
  389. "group (GO Dev Addr " MACSTR ")", MAC2STR(go_dev_addr));
  390. for (s = wpa_s->conf->ssid; s; s = s->next) {
  391. if (s->disabled == 2 &&
  392. os_memcmp(go_dev_addr, s->bssid, ETH_ALEN) == 0 &&
  393. s->ssid_len == ssid->ssid_len &&
  394. os_memcmp(ssid->ssid, s->ssid, ssid->ssid_len) == 0)
  395. break;
  396. }
  397. if (s) {
  398. wpa_printf(MSG_DEBUG, "P2P: Update existing persistent group "
  399. "entry");
  400. if (ssid->passphrase && !s->passphrase)
  401. changed = 1;
  402. else if (ssid->passphrase && s->passphrase &&
  403. os_strcmp(ssid->passphrase, s->passphrase) != 0)
  404. changed = 1;
  405. } else {
  406. wpa_printf(MSG_DEBUG, "P2P: Create a new persistent group "
  407. "entry");
  408. changed = 1;
  409. s = wpa_config_add_network(wpa_s->conf);
  410. if (s == NULL)
  411. return -1;
  412. /*
  413. * Instead of network_added we emit persistent_group_added
  414. * notification. Also to keep the defense checks in
  415. * persistent_group obj registration method, we set the
  416. * relevant flags in s to designate it as a persistent group.
  417. */
  418. s->p2p_group = 1;
  419. s->p2p_persistent_group = 1;
  420. wpas_notify_persistent_group_added(wpa_s, s);
  421. wpa_config_set_network_defaults(s);
  422. }
  423. s->p2p_group = 1;
  424. s->p2p_persistent_group = 1;
  425. s->disabled = 2;
  426. s->bssid_set = 1;
  427. os_memcpy(s->bssid, go_dev_addr, ETH_ALEN);
  428. s->mode = ssid->mode;
  429. s->auth_alg = WPA_AUTH_ALG_OPEN;
  430. s->key_mgmt = WPA_KEY_MGMT_PSK;
  431. s->proto = WPA_PROTO_RSN;
  432. s->pairwise_cipher = WPA_CIPHER_CCMP;
  433. s->export_keys = 1;
  434. if (ssid->passphrase) {
  435. os_free(s->passphrase);
  436. s->passphrase = os_strdup(ssid->passphrase);
  437. }
  438. if (ssid->psk_set) {
  439. s->psk_set = 1;
  440. os_memcpy(s->psk, ssid->psk, 32);
  441. }
  442. if (s->passphrase && !s->psk_set)
  443. wpa_config_update_psk(s);
  444. if (s->ssid == NULL || s->ssid_len < ssid->ssid_len) {
  445. os_free(s->ssid);
  446. s->ssid = os_malloc(ssid->ssid_len);
  447. }
  448. if (s->ssid) {
  449. s->ssid_len = ssid->ssid_len;
  450. os_memcpy(s->ssid, ssid->ssid, s->ssid_len);
  451. }
  452. #ifndef CONFIG_NO_CONFIG_WRITE
  453. if (changed && wpa_s->conf->update_config &&
  454. wpa_config_write(wpa_s->confname, wpa_s->conf)) {
  455. wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
  456. }
  457. #endif /* CONFIG_NO_CONFIG_WRITE */
  458. return s->id;
  459. }
  460. static void wpas_p2p_add_persistent_group_client(struct wpa_supplicant *wpa_s,
  461. const u8 *addr)
  462. {
  463. struct wpa_ssid *ssid, *s;
  464. u8 *n;
  465. size_t i;
  466. int found = 0;
  467. ssid = wpa_s->current_ssid;
  468. if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GO ||
  469. !ssid->p2p_persistent_group)
  470. return;
  471. for (s = wpa_s->parent->conf->ssid; s; s = s->next) {
  472. if (s->disabled != 2 || s->mode != WPAS_MODE_P2P_GO)
  473. continue;
  474. if (s->ssid_len == ssid->ssid_len &&
  475. os_memcmp(s->ssid, ssid->ssid, s->ssid_len) == 0)
  476. break;
  477. }
  478. if (s == NULL)
  479. return;
  480. for (i = 0; s->p2p_client_list && i < s->num_p2p_clients; i++) {
  481. if (os_memcmp(s->p2p_client_list + i * ETH_ALEN, addr,
  482. ETH_ALEN) != 0)
  483. continue;
  484. if (i == s->num_p2p_clients - 1)
  485. return; /* already the most recent entry */
  486. /* move the entry to mark it most recent */
  487. os_memmove(s->p2p_client_list + i * ETH_ALEN,
  488. s->p2p_client_list + (i + 1) * ETH_ALEN,
  489. (s->num_p2p_clients - i - 1) * ETH_ALEN);
  490. os_memcpy(s->p2p_client_list +
  491. (s->num_p2p_clients - 1) * ETH_ALEN, addr, ETH_ALEN);
  492. found = 1;
  493. break;
  494. }
  495. if (!found && s->num_p2p_clients < P2P_MAX_STORED_CLIENTS) {
  496. n = os_realloc_array(s->p2p_client_list,
  497. s->num_p2p_clients + 1, ETH_ALEN);
  498. if (n == NULL)
  499. return;
  500. os_memcpy(n + s->num_p2p_clients * ETH_ALEN, addr, ETH_ALEN);
  501. s->p2p_client_list = n;
  502. s->num_p2p_clients++;
  503. } else if (!found) {
  504. /* Not enough room for an additional entry - drop the oldest
  505. * entry */
  506. os_memmove(s->p2p_client_list,
  507. s->p2p_client_list + ETH_ALEN,
  508. (s->num_p2p_clients - 1) * ETH_ALEN);
  509. os_memcpy(s->p2p_client_list +
  510. (s->num_p2p_clients - 1) * ETH_ALEN,
  511. addr, ETH_ALEN);
  512. }
  513. #ifndef CONFIG_NO_CONFIG_WRITE
  514. if (wpa_s->parent->conf->update_config &&
  515. wpa_config_write(wpa_s->parent->confname, wpa_s->parent->conf))
  516. wpa_printf(MSG_DEBUG, "P2P: Failed to update configuration");
  517. #endif /* CONFIG_NO_CONFIG_WRITE */
  518. }
  519. static void wpas_group_formation_completed(struct wpa_supplicant *wpa_s,
  520. int success)
  521. {
  522. struct wpa_ssid *ssid;
  523. const char *ssid_txt;
  524. int client;
  525. int persistent;
  526. u8 go_dev_addr[ETH_ALEN];
  527. int network_id = -1;
  528. /*
  529. * This callback is likely called for the main interface. Update wpa_s
  530. * to use the group interface if a new interface was created for the
  531. * group.
  532. */
  533. if (wpa_s->global->p2p_group_formation)
  534. wpa_s = wpa_s->global->p2p_group_formation;
  535. wpa_s->global->p2p_group_formation = NULL;
  536. wpa_s->p2p_in_provisioning = 0;
  537. if (!success) {
  538. wpa_msg(wpa_s->parent, MSG_INFO,
  539. P2P_EVENT_GROUP_FORMATION_FAILURE);
  540. wpas_p2p_group_delete(wpa_s,
  541. P2P_GROUP_REMOVAL_FORMATION_FAILED);
  542. return;
  543. }
  544. wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_FORMATION_SUCCESS);
  545. ssid = wpa_s->current_ssid;
  546. if (ssid && ssid->mode == WPAS_MODE_P2P_GROUP_FORMATION) {
  547. ssid->mode = WPAS_MODE_P2P_GO;
  548. p2p_group_notif_formation_done(wpa_s->p2p_group);
  549. wpa_supplicant_ap_mac_addr_filter(wpa_s, NULL);
  550. }
  551. persistent = 0;
  552. if (ssid) {
  553. ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
  554. client = ssid->mode == WPAS_MODE_INFRA;
  555. if (ssid->mode == WPAS_MODE_P2P_GO) {
  556. persistent = ssid->p2p_persistent_group;
  557. os_memcpy(go_dev_addr, wpa_s->global->p2p_dev_addr,
  558. ETH_ALEN);
  559. } else
  560. persistent = wpas_p2p_persistent_group(wpa_s,
  561. go_dev_addr,
  562. ssid->ssid,
  563. ssid->ssid_len);
  564. } else {
  565. ssid_txt = "";
  566. client = wpa_s->p2p_group_interface ==
  567. P2P_GROUP_INTERFACE_CLIENT;
  568. os_memset(go_dev_addr, 0, ETH_ALEN);
  569. }
  570. wpa_s->show_group_started = 0;
  571. if (client) {
  572. /*
  573. * Indicate event only after successfully completed 4-way
  574. * handshake, i.e., when the interface is ready for data
  575. * packets.
  576. */
  577. wpa_s->show_group_started = 1;
  578. } else if (ssid && ssid->passphrase == NULL && ssid->psk_set) {
  579. char psk[65];
  580. wpa_snprintf_hex(psk, sizeof(psk), ssid->psk, 32);
  581. wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
  582. "%s GO ssid=\"%s\" freq=%d psk=%s go_dev_addr=" MACSTR
  583. "%s",
  584. wpa_s->ifname, ssid_txt, ssid->frequency, psk,
  585. MAC2STR(go_dev_addr),
  586. persistent ? " [PERSISTENT]" : "");
  587. wpas_p2p_cross_connect_setup(wpa_s);
  588. wpas_p2p_set_group_idle_timeout(wpa_s);
  589. } else {
  590. wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
  591. "%s GO ssid=\"%s\" freq=%d passphrase=\"%s\" "
  592. "go_dev_addr=" MACSTR "%s",
  593. wpa_s->ifname, ssid_txt, ssid ? ssid->frequency : 0,
  594. ssid && ssid->passphrase ? ssid->passphrase : "",
  595. MAC2STR(go_dev_addr),
  596. persistent ? " [PERSISTENT]" : "");
  597. wpas_p2p_cross_connect_setup(wpa_s);
  598. wpas_p2p_set_group_idle_timeout(wpa_s);
  599. }
  600. if (persistent)
  601. network_id = wpas_p2p_store_persistent_group(wpa_s->parent,
  602. ssid, go_dev_addr);
  603. if (network_id < 0 && ssid)
  604. network_id = ssid->id;
  605. if (!client)
  606. wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0);
  607. }
  608. static void wpas_p2p_send_action_tx_status(struct wpa_supplicant *wpa_s,
  609. unsigned int freq,
  610. const u8 *dst, const u8 *src,
  611. const u8 *bssid,
  612. const u8 *data, size_t data_len,
  613. enum offchannel_send_action_result
  614. result)
  615. {
  616. enum p2p_send_action_result res = P2P_SEND_ACTION_SUCCESS;
  617. if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
  618. return;
  619. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  620. return;
  621. switch (result) {
  622. case OFFCHANNEL_SEND_ACTION_SUCCESS:
  623. res = P2P_SEND_ACTION_SUCCESS;
  624. break;
  625. case OFFCHANNEL_SEND_ACTION_NO_ACK:
  626. res = P2P_SEND_ACTION_NO_ACK;
  627. break;
  628. case OFFCHANNEL_SEND_ACTION_FAILED:
  629. res = P2P_SEND_ACTION_FAILED;
  630. break;
  631. }
  632. p2p_send_action_cb(wpa_s->global->p2p, freq, dst, src, bssid, res);
  633. if (result != OFFCHANNEL_SEND_ACTION_SUCCESS &&
  634. wpa_s->pending_pd_before_join &&
  635. (os_memcmp(dst, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
  636. os_memcmp(dst, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) {
  637. wpa_s->pending_pd_before_join = 0;
  638. if (wpa_s->p2p_fallback_to_go_neg) {
  639. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: No ACK for PD Req "
  640. "during p2p_connect-auto");
  641. wpas_p2p_fallback_to_go_neg(wpa_s, 0);
  642. return;
  643. }
  644. wpa_printf(MSG_DEBUG, "P2P: Starting pending "
  645. "join-existing-group operation (no ACK for PD "
  646. "Req)");
  647. wpas_p2p_join_start(wpa_s);
  648. }
  649. }
  650. static int wpas_send_action(void *ctx, unsigned int freq, const u8 *dst,
  651. const u8 *src, const u8 *bssid, const u8 *buf,
  652. size_t len, unsigned int wait_time)
  653. {
  654. struct wpa_supplicant *wpa_s = ctx;
  655. return offchannel_send_action(wpa_s, freq, dst, src, bssid, buf, len,
  656. wait_time,
  657. wpas_p2p_send_action_tx_status, 1);
  658. }
  659. static void wpas_send_action_done(void *ctx)
  660. {
  661. struct wpa_supplicant *wpa_s = ctx;
  662. offchannel_send_action_done(wpa_s);
  663. }
  664. static int wpas_copy_go_neg_results(struct wpa_supplicant *wpa_s,
  665. struct p2p_go_neg_results *params)
  666. {
  667. if (wpa_s->go_params == NULL) {
  668. wpa_s->go_params = os_malloc(sizeof(*params));
  669. if (wpa_s->go_params == NULL)
  670. return -1;
  671. }
  672. os_memcpy(wpa_s->go_params, params, sizeof(*params));
  673. return 0;
  674. }
  675. static void wpas_start_wps_enrollee(struct wpa_supplicant *wpa_s,
  676. struct p2p_go_neg_results *res)
  677. {
  678. wpa_printf(MSG_DEBUG, "P2P: Start WPS Enrollee for peer " MACSTR,
  679. MAC2STR(res->peer_interface_addr));
  680. wpa_hexdump_ascii(MSG_DEBUG, "P2P: Start WPS Enrollee for SSID",
  681. res->ssid, res->ssid_len);
  682. wpa_supplicant_ap_deinit(wpa_s);
  683. wpas_copy_go_neg_results(wpa_s, res);
  684. if (res->wps_method == WPS_PBC)
  685. wpas_wps_start_pbc(wpa_s, res->peer_interface_addr, 1);
  686. else {
  687. u16 dev_pw_id = DEV_PW_DEFAULT;
  688. if (wpa_s->p2p_wps_method == WPS_PIN_KEYPAD)
  689. dev_pw_id = DEV_PW_REGISTRAR_SPECIFIED;
  690. wpas_wps_start_pin(wpa_s, res->peer_interface_addr,
  691. wpa_s->p2p_pin, 1, dev_pw_id);
  692. }
  693. }
  694. static void p2p_go_configured(void *ctx, void *data)
  695. {
  696. struct wpa_supplicant *wpa_s = ctx;
  697. struct p2p_go_neg_results *params = data;
  698. struct wpa_ssid *ssid;
  699. int network_id = -1;
  700. ssid = wpa_s->current_ssid;
  701. if (ssid && ssid->mode == WPAS_MODE_P2P_GO) {
  702. wpa_printf(MSG_DEBUG, "P2P: Group setup without provisioning");
  703. if (wpa_s->global->p2p_group_formation == wpa_s)
  704. wpa_s->global->p2p_group_formation = NULL;
  705. wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
  706. "%s GO ssid=\"%s\" freq=%d passphrase=\"%s\" "
  707. "go_dev_addr=" MACSTR "%s",
  708. wpa_s->ifname,
  709. wpa_ssid_txt(ssid->ssid, ssid->ssid_len),
  710. ssid->frequency,
  711. params->passphrase ? params->passphrase : "",
  712. MAC2STR(wpa_s->global->p2p_dev_addr),
  713. params->persistent_group ? " [PERSISTENT]" : "");
  714. if (params->persistent_group)
  715. network_id = wpas_p2p_store_persistent_group(
  716. wpa_s->parent, ssid,
  717. wpa_s->global->p2p_dev_addr);
  718. if (network_id < 0)
  719. network_id = ssid->id;
  720. wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 0);
  721. wpas_p2p_cross_connect_setup(wpa_s);
  722. wpas_p2p_set_group_idle_timeout(wpa_s);
  723. return;
  724. }
  725. wpa_printf(MSG_DEBUG, "P2P: Setting up WPS for GO provisioning");
  726. if (wpa_supplicant_ap_mac_addr_filter(wpa_s,
  727. params->peer_interface_addr)) {
  728. wpa_printf(MSG_DEBUG, "P2P: Failed to setup MAC address "
  729. "filtering");
  730. return;
  731. }
  732. if (params->wps_method == WPS_PBC)
  733. wpa_supplicant_ap_wps_pbc(wpa_s, params->peer_interface_addr,
  734. params->peer_device_addr);
  735. else if (wpa_s->p2p_pin[0])
  736. wpa_supplicant_ap_wps_pin(wpa_s, params->peer_interface_addr,
  737. wpa_s->p2p_pin, NULL, 0, 0);
  738. os_free(wpa_s->go_params);
  739. wpa_s->go_params = NULL;
  740. }
  741. static void wpas_start_wps_go(struct wpa_supplicant *wpa_s,
  742. struct p2p_go_neg_results *params,
  743. int group_formation)
  744. {
  745. struct wpa_ssid *ssid;
  746. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Starting GO");
  747. if (wpas_copy_go_neg_results(wpa_s, params) < 0) {
  748. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not copy GO Negotiation "
  749. "results");
  750. return;
  751. }
  752. ssid = wpa_config_add_network(wpa_s->conf);
  753. if (ssid == NULL) {
  754. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Could not add network for GO");
  755. return;
  756. }
  757. wpa_s->show_group_started = 0;
  758. wpa_config_set_network_defaults(ssid);
  759. ssid->temporary = 1;
  760. ssid->p2p_group = 1;
  761. ssid->p2p_persistent_group = params->persistent_group;
  762. ssid->mode = group_formation ? WPAS_MODE_P2P_GROUP_FORMATION :
  763. WPAS_MODE_P2P_GO;
  764. ssid->frequency = params->freq;
  765. ssid->ht40 = params->ht40;
  766. ssid->ssid = os_zalloc(params->ssid_len + 1);
  767. if (ssid->ssid) {
  768. os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
  769. ssid->ssid_len = params->ssid_len;
  770. }
  771. ssid->auth_alg = WPA_AUTH_ALG_OPEN;
  772. ssid->key_mgmt = WPA_KEY_MGMT_PSK;
  773. ssid->proto = WPA_PROTO_RSN;
  774. ssid->pairwise_cipher = WPA_CIPHER_CCMP;
  775. ssid->passphrase = os_strdup(params->passphrase);
  776. if (ssid->passphrase == NULL) {
  777. wpa_msg(wpa_s, MSG_ERROR, "P2P: Failed to copy passphrase for "
  778. "GO");
  779. wpa_config_remove_network(wpa_s->conf, ssid->id);
  780. return;
  781. }
  782. wpa_config_update_psk(ssid);
  783. ssid->ap_max_inactivity = wpa_s->parent->conf->p2p_go_max_inactivity;
  784. wpa_s->ap_configured_cb = p2p_go_configured;
  785. wpa_s->ap_configured_cb_ctx = wpa_s;
  786. wpa_s->ap_configured_cb_data = wpa_s->go_params;
  787. wpa_s->connect_without_scan = ssid;
  788. wpa_s->reassociate = 1;
  789. wpa_s->disconnected = 0;
  790. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Request scan (that will be skipped) to "
  791. "start GO)");
  792. wpa_supplicant_req_scan(wpa_s, 0, 0);
  793. }
  794. static void wpas_p2p_clone_config(struct wpa_supplicant *dst,
  795. const struct wpa_supplicant *src)
  796. {
  797. struct wpa_config *d;
  798. const struct wpa_config *s;
  799. d = dst->conf;
  800. s = src->conf;
  801. #define C(n) if (s->n) d->n = os_strdup(s->n)
  802. C(device_name);
  803. C(manufacturer);
  804. C(model_name);
  805. C(model_number);
  806. C(serial_number);
  807. C(config_methods);
  808. #undef C
  809. os_memcpy(d->device_type, s->device_type, WPS_DEV_TYPE_LEN);
  810. os_memcpy(d->sec_device_type, s->sec_device_type,
  811. sizeof(d->sec_device_type));
  812. d->num_sec_device_types = s->num_sec_device_types;
  813. d->p2p_group_idle = s->p2p_group_idle;
  814. d->p2p_intra_bss = s->p2p_intra_bss;
  815. d->persistent_reconnect = s->persistent_reconnect;
  816. d->max_num_sta = s->max_num_sta;
  817. d->pbc_in_m1 = s->pbc_in_m1;
  818. }
  819. static int wpas_p2p_add_group_interface(struct wpa_supplicant *wpa_s,
  820. enum wpa_driver_if_type type)
  821. {
  822. char ifname[120], force_ifname[120];
  823. if (wpa_s->pending_interface_name[0]) {
  824. wpa_printf(MSG_DEBUG, "P2P: Pending virtual interface exists "
  825. "- skip creation of a new one");
  826. if (is_zero_ether_addr(wpa_s->pending_interface_addr)) {
  827. wpa_printf(MSG_DEBUG, "P2P: Pending virtual address "
  828. "unknown?! ifname='%s'",
  829. wpa_s->pending_interface_name);
  830. return -1;
  831. }
  832. return 0;
  833. }
  834. os_snprintf(ifname, sizeof(ifname), "p2p-%s-%d", wpa_s->ifname,
  835. wpa_s->p2p_group_idx);
  836. if (os_strlen(ifname) >= IFNAMSIZ &&
  837. os_strlen(wpa_s->ifname) < IFNAMSIZ) {
  838. /* Try to avoid going over the IFNAMSIZ length limit */
  839. os_snprintf(ifname, sizeof(ifname), "p2p-%d",
  840. wpa_s->p2p_group_idx);
  841. }
  842. force_ifname[0] = '\0';
  843. wpa_printf(MSG_DEBUG, "P2P: Create a new interface %s for the group",
  844. ifname);
  845. wpa_s->p2p_group_idx++;
  846. wpa_s->pending_interface_type = type;
  847. if (wpa_drv_if_add(wpa_s, type, ifname, NULL, NULL, force_ifname,
  848. wpa_s->pending_interface_addr, NULL) < 0) {
  849. wpa_printf(MSG_ERROR, "P2P: Failed to create new group "
  850. "interface");
  851. return -1;
  852. }
  853. if (force_ifname[0]) {
  854. wpa_printf(MSG_DEBUG, "P2P: Driver forced interface name %s",
  855. force_ifname);
  856. os_strlcpy(wpa_s->pending_interface_name, force_ifname,
  857. sizeof(wpa_s->pending_interface_name));
  858. } else
  859. os_strlcpy(wpa_s->pending_interface_name, ifname,
  860. sizeof(wpa_s->pending_interface_name));
  861. wpa_printf(MSG_DEBUG, "P2P: Created pending virtual interface %s addr "
  862. MACSTR, wpa_s->pending_interface_name,
  863. MAC2STR(wpa_s->pending_interface_addr));
  864. return 0;
  865. }
  866. static void wpas_p2p_remove_pending_group_interface(
  867. struct wpa_supplicant *wpa_s)
  868. {
  869. if (!wpa_s->pending_interface_name[0] ||
  870. is_zero_ether_addr(wpa_s->pending_interface_addr))
  871. return; /* No pending virtual interface */
  872. wpa_printf(MSG_DEBUG, "P2P: Removing pending group interface %s",
  873. wpa_s->pending_interface_name);
  874. wpa_drv_if_remove(wpa_s, wpa_s->pending_interface_type,
  875. wpa_s->pending_interface_name);
  876. os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
  877. wpa_s->pending_interface_name[0] = '\0';
  878. }
  879. static struct wpa_supplicant *
  880. wpas_p2p_init_group_interface(struct wpa_supplicant *wpa_s, int go)
  881. {
  882. struct wpa_interface iface;
  883. struct wpa_supplicant *group_wpa_s;
  884. if (!wpa_s->pending_interface_name[0]) {
  885. wpa_printf(MSG_ERROR, "P2P: No pending group interface");
  886. if (!wpas_p2p_create_iface(wpa_s))
  887. return NULL;
  888. /*
  889. * Something has forced us to remove the pending interface; try
  890. * to create a new one and hope for the best that we will get
  891. * the same local address.
  892. */
  893. if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
  894. WPA_IF_P2P_CLIENT) < 0)
  895. return NULL;
  896. }
  897. os_memset(&iface, 0, sizeof(iface));
  898. iface.ifname = wpa_s->pending_interface_name;
  899. iface.driver = wpa_s->driver->name;
  900. iface.ctrl_interface = wpa_s->conf->ctrl_interface;
  901. iface.driver_param = wpa_s->conf->driver_param;
  902. group_wpa_s = wpa_supplicant_add_iface(wpa_s->global, &iface);
  903. if (group_wpa_s == NULL) {
  904. wpa_printf(MSG_ERROR, "P2P: Failed to create new "
  905. "wpa_supplicant interface");
  906. return NULL;
  907. }
  908. wpa_s->pending_interface_name[0] = '\0';
  909. group_wpa_s->parent = wpa_s;
  910. group_wpa_s->p2p_group_interface = go ? P2P_GROUP_INTERFACE_GO :
  911. P2P_GROUP_INTERFACE_CLIENT;
  912. wpa_s->global->p2p_group_formation = group_wpa_s;
  913. wpas_p2p_clone_config(group_wpa_s, wpa_s);
  914. return group_wpa_s;
  915. }
  916. static void wpas_p2p_group_formation_timeout(void *eloop_ctx,
  917. void *timeout_ctx)
  918. {
  919. struct wpa_supplicant *wpa_s = eloop_ctx;
  920. wpa_printf(MSG_DEBUG, "P2P: Group Formation timed out");
  921. if (wpa_s->global->p2p)
  922. p2p_group_formation_failed(wpa_s->global->p2p);
  923. else if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  924. wpa_drv_p2p_group_formation_failed(wpa_s);
  925. wpas_group_formation_completed(wpa_s, 0);
  926. }
  927. void wpas_go_neg_completed(void *ctx, struct p2p_go_neg_results *res)
  928. {
  929. struct wpa_supplicant *wpa_s = ctx;
  930. if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
  931. wpa_drv_cancel_remain_on_channel(wpa_s);
  932. wpa_s->off_channel_freq = 0;
  933. wpa_s->roc_waiting_drv_freq = 0;
  934. }
  935. if (res->status) {
  936. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_FAILURE "status=%d",
  937. res->status);
  938. wpas_notify_p2p_go_neg_completed(wpa_s, res);
  939. wpas_p2p_remove_pending_group_interface(wpa_s);
  940. return;
  941. }
  942. if (wpa_s->p2p_go_ht40)
  943. res->ht40 = 1;
  944. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_SUCCESS);
  945. wpas_notify_p2p_go_neg_completed(wpa_s, res);
  946. if (res->role_go && wpa_s->p2p_persistent_id >= 0) {
  947. struct wpa_ssid *ssid;
  948. ssid = wpa_config_get_network(wpa_s->conf,
  949. wpa_s->p2p_persistent_id);
  950. if (ssid && ssid->disabled == 2 &&
  951. ssid->mode == WPAS_MODE_P2P_GO && ssid->passphrase) {
  952. size_t len = os_strlen(ssid->passphrase);
  953. wpa_printf(MSG_DEBUG, "P2P: Override passphrase based "
  954. "on requested persistent group");
  955. os_memcpy(res->passphrase, ssid->passphrase, len);
  956. res->passphrase[len] = '\0';
  957. }
  958. }
  959. if (wpa_s->create_p2p_iface) {
  960. struct wpa_supplicant *group_wpa_s =
  961. wpas_p2p_init_group_interface(wpa_s, res->role_go);
  962. if (group_wpa_s == NULL) {
  963. wpas_p2p_remove_pending_group_interface(wpa_s);
  964. return;
  965. }
  966. if (group_wpa_s != wpa_s) {
  967. os_memcpy(group_wpa_s->p2p_pin, wpa_s->p2p_pin,
  968. sizeof(group_wpa_s->p2p_pin));
  969. group_wpa_s->p2p_wps_method = wpa_s->p2p_wps_method;
  970. }
  971. os_memset(wpa_s->pending_interface_addr, 0, ETH_ALEN);
  972. wpa_s->pending_interface_name[0] = '\0';
  973. group_wpa_s->p2p_in_provisioning = 1;
  974. if (res->role_go)
  975. wpas_start_wps_go(group_wpa_s, res, 1);
  976. else
  977. wpas_start_wps_enrollee(group_wpa_s, res);
  978. } else {
  979. wpa_s->p2p_in_provisioning = 1;
  980. wpa_s->global->p2p_group_formation = wpa_s;
  981. if (res->role_go)
  982. wpas_start_wps_go(wpa_s, res, 1);
  983. else
  984. wpas_start_wps_enrollee(ctx, res);
  985. }
  986. wpa_s->p2p_long_listen = 0;
  987. eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
  988. eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
  989. eloop_register_timeout(15 + res->peer_config_timeout / 100,
  990. (res->peer_config_timeout % 100) * 10000,
  991. wpas_p2p_group_formation_timeout, wpa_s, NULL);
  992. }
  993. void wpas_go_neg_req_rx(void *ctx, const u8 *src, u16 dev_passwd_id)
  994. {
  995. struct wpa_supplicant *wpa_s = ctx;
  996. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_GO_NEG_REQUEST MACSTR
  997. " dev_passwd_id=%u", MAC2STR(src), dev_passwd_id);
  998. wpas_notify_p2p_go_neg_req(wpa_s, src, dev_passwd_id);
  999. }
  1000. void wpas_dev_found(void *ctx, const u8 *addr,
  1001. const struct p2p_peer_info *info,
  1002. int new_device)
  1003. {
  1004. #ifndef CONFIG_NO_STDOUT_DEBUG
  1005. struct wpa_supplicant *wpa_s = ctx;
  1006. char devtype[WPS_DEV_TYPE_BUFSIZE];
  1007. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_FOUND MACSTR
  1008. " p2p_dev_addr=" MACSTR
  1009. " pri_dev_type=%s name='%s' config_methods=0x%x "
  1010. "dev_capab=0x%x group_capab=0x%x",
  1011. MAC2STR(addr), MAC2STR(info->p2p_device_addr),
  1012. wps_dev_type_bin2str(info->pri_dev_type, devtype,
  1013. sizeof(devtype)),
  1014. info->device_name, info->config_methods,
  1015. info->dev_capab, info->group_capab);
  1016. #endif /* CONFIG_NO_STDOUT_DEBUG */
  1017. wpas_notify_p2p_device_found(ctx, info->p2p_device_addr, new_device);
  1018. }
  1019. static void wpas_dev_lost(void *ctx, const u8 *dev_addr)
  1020. {
  1021. struct wpa_supplicant *wpa_s = ctx;
  1022. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_DEVICE_LOST
  1023. "p2p_dev_addr=" MACSTR, MAC2STR(dev_addr));
  1024. wpas_notify_p2p_device_lost(wpa_s, dev_addr);
  1025. }
  1026. static int wpas_start_listen(void *ctx, unsigned int freq,
  1027. unsigned int duration,
  1028. const struct wpabuf *probe_resp_ie)
  1029. {
  1030. struct wpa_supplicant *wpa_s = ctx;
  1031. wpa_drv_set_ap_wps_ie(wpa_s, NULL, probe_resp_ie, NULL);
  1032. if (wpa_drv_probe_req_report(wpa_s, 1) < 0) {
  1033. wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver to "
  1034. "report received Probe Request frames");
  1035. return -1;
  1036. }
  1037. wpa_s->pending_listen_freq = freq;
  1038. wpa_s->pending_listen_duration = duration;
  1039. if (wpa_drv_remain_on_channel(wpa_s, freq, duration) < 0) {
  1040. wpa_printf(MSG_DEBUG, "P2P: Failed to request the driver "
  1041. "to remain on channel (%u MHz) for Listen "
  1042. "state", freq);
  1043. wpa_s->pending_listen_freq = 0;
  1044. return -1;
  1045. }
  1046. wpa_s->off_channel_freq = 0;
  1047. wpa_s->roc_waiting_drv_freq = freq;
  1048. return 0;
  1049. }
  1050. static void wpas_stop_listen(void *ctx)
  1051. {
  1052. struct wpa_supplicant *wpa_s = ctx;
  1053. if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
  1054. wpa_drv_cancel_remain_on_channel(wpa_s);
  1055. wpa_s->off_channel_freq = 0;
  1056. wpa_s->roc_waiting_drv_freq = 0;
  1057. }
  1058. wpa_drv_set_ap_wps_ie(wpa_s, NULL, NULL, NULL);
  1059. wpa_drv_probe_req_report(wpa_s, 0);
  1060. }
  1061. static int wpas_send_probe_resp(void *ctx, const struct wpabuf *buf)
  1062. {
  1063. struct wpa_supplicant *wpa_s = ctx;
  1064. return wpa_drv_send_mlme(wpa_s, wpabuf_head(buf), wpabuf_len(buf), 1);
  1065. }
  1066. static struct p2p_srv_bonjour *
  1067. wpas_p2p_service_get_bonjour(struct wpa_supplicant *wpa_s,
  1068. const struct wpabuf *query)
  1069. {
  1070. struct p2p_srv_bonjour *bsrv;
  1071. size_t len;
  1072. len = wpabuf_len(query);
  1073. dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
  1074. struct p2p_srv_bonjour, list) {
  1075. if (len == wpabuf_len(bsrv->query) &&
  1076. os_memcmp(wpabuf_head(query), wpabuf_head(bsrv->query),
  1077. len) == 0)
  1078. return bsrv;
  1079. }
  1080. return NULL;
  1081. }
  1082. static struct p2p_srv_upnp *
  1083. wpas_p2p_service_get_upnp(struct wpa_supplicant *wpa_s, u8 version,
  1084. const char *service)
  1085. {
  1086. struct p2p_srv_upnp *usrv;
  1087. dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
  1088. struct p2p_srv_upnp, list) {
  1089. if (version == usrv->version &&
  1090. os_strcmp(service, usrv->service) == 0)
  1091. return usrv;
  1092. }
  1093. return NULL;
  1094. }
  1095. static void wpas_sd_add_proto_not_avail(struct wpabuf *resp, u8 srv_proto,
  1096. u8 srv_trans_id)
  1097. {
  1098. u8 *len_pos;
  1099. if (wpabuf_tailroom(resp) < 5)
  1100. return;
  1101. /* Length (to be filled) */
  1102. len_pos = wpabuf_put(resp, 2);
  1103. wpabuf_put_u8(resp, srv_proto);
  1104. wpabuf_put_u8(resp, srv_trans_id);
  1105. /* Status Code */
  1106. wpabuf_put_u8(resp, P2P_SD_PROTO_NOT_AVAILABLE);
  1107. /* Response Data: empty */
  1108. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
  1109. }
  1110. static void wpas_sd_all_bonjour(struct wpa_supplicant *wpa_s,
  1111. struct wpabuf *resp, u8 srv_trans_id)
  1112. {
  1113. struct p2p_srv_bonjour *bsrv;
  1114. u8 *len_pos;
  1115. wpa_printf(MSG_DEBUG, "P2P: SD Request for all Bonjour services");
  1116. if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
  1117. wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available");
  1118. return;
  1119. }
  1120. dl_list_for_each(bsrv, &wpa_s->global->p2p_srv_bonjour,
  1121. struct p2p_srv_bonjour, list) {
  1122. if (wpabuf_tailroom(resp) <
  1123. 5 + wpabuf_len(bsrv->query) + wpabuf_len(bsrv->resp))
  1124. return;
  1125. /* Length (to be filled) */
  1126. len_pos = wpabuf_put(resp, 2);
  1127. wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
  1128. wpabuf_put_u8(resp, srv_trans_id);
  1129. /* Status Code */
  1130. wpabuf_put_u8(resp, P2P_SD_SUCCESS);
  1131. wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service",
  1132. wpabuf_head(bsrv->resp),
  1133. wpabuf_len(bsrv->resp));
  1134. /* Response Data */
  1135. wpabuf_put_buf(resp, bsrv->query); /* Key */
  1136. wpabuf_put_buf(resp, bsrv->resp); /* Value */
  1137. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
  1138. 2);
  1139. }
  1140. }
  1141. static void wpas_sd_req_bonjour(struct wpa_supplicant *wpa_s,
  1142. struct wpabuf *resp, u8 srv_trans_id,
  1143. const u8 *query, size_t query_len)
  1144. {
  1145. struct p2p_srv_bonjour *bsrv;
  1146. struct wpabuf buf;
  1147. u8 *len_pos;
  1148. wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for Bonjour",
  1149. query, query_len);
  1150. if (dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
  1151. wpa_printf(MSG_DEBUG, "P2P: Bonjour protocol not available");
  1152. wpas_sd_add_proto_not_avail(resp, P2P_SERV_BONJOUR,
  1153. srv_trans_id);
  1154. return;
  1155. }
  1156. if (query_len == 0) {
  1157. wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
  1158. return;
  1159. }
  1160. if (wpabuf_tailroom(resp) < 5)
  1161. return;
  1162. /* Length (to be filled) */
  1163. len_pos = wpabuf_put(resp, 2);
  1164. wpabuf_put_u8(resp, P2P_SERV_BONJOUR);
  1165. wpabuf_put_u8(resp, srv_trans_id);
  1166. wpabuf_set(&buf, query, query_len);
  1167. bsrv = wpas_p2p_service_get_bonjour(wpa_s, &buf);
  1168. if (bsrv == NULL) {
  1169. wpa_printf(MSG_DEBUG, "P2P: Requested Bonjour service not "
  1170. "available");
  1171. /* Status Code */
  1172. wpabuf_put_u8(resp, P2P_SD_REQUESTED_INFO_NOT_AVAILABLE);
  1173. /* Response Data: empty */
  1174. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
  1175. 2);
  1176. return;
  1177. }
  1178. /* Status Code */
  1179. wpabuf_put_u8(resp, P2P_SD_SUCCESS);
  1180. wpa_hexdump_ascii(MSG_DEBUG, "P2P: Matching Bonjour service",
  1181. wpabuf_head(bsrv->resp), wpabuf_len(bsrv->resp));
  1182. if (wpabuf_tailroom(resp) >=
  1183. wpabuf_len(bsrv->query) + wpabuf_len(bsrv->resp)) {
  1184. /* Response Data */
  1185. wpabuf_put_buf(resp, bsrv->query); /* Key */
  1186. wpabuf_put_buf(resp, bsrv->resp); /* Value */
  1187. }
  1188. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
  1189. }
  1190. static void wpas_sd_all_upnp(struct wpa_supplicant *wpa_s,
  1191. struct wpabuf *resp, u8 srv_trans_id)
  1192. {
  1193. struct p2p_srv_upnp *usrv;
  1194. u8 *len_pos;
  1195. wpa_printf(MSG_DEBUG, "P2P: SD Request for all UPnP services");
  1196. if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
  1197. wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available");
  1198. return;
  1199. }
  1200. dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
  1201. struct p2p_srv_upnp, list) {
  1202. if (wpabuf_tailroom(resp) < 5 + 1 + os_strlen(usrv->service))
  1203. return;
  1204. /* Length (to be filled) */
  1205. len_pos = wpabuf_put(resp, 2);
  1206. wpabuf_put_u8(resp, P2P_SERV_UPNP);
  1207. wpabuf_put_u8(resp, srv_trans_id);
  1208. /* Status Code */
  1209. wpabuf_put_u8(resp, P2P_SD_SUCCESS);
  1210. /* Response Data */
  1211. wpabuf_put_u8(resp, usrv->version);
  1212. wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s",
  1213. usrv->service);
  1214. wpabuf_put_str(resp, usrv->service);
  1215. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos -
  1216. 2);
  1217. }
  1218. }
  1219. static void wpas_sd_req_upnp(struct wpa_supplicant *wpa_s,
  1220. struct wpabuf *resp, u8 srv_trans_id,
  1221. const u8 *query, size_t query_len)
  1222. {
  1223. struct p2p_srv_upnp *usrv;
  1224. u8 *len_pos;
  1225. u8 version;
  1226. char *str;
  1227. int count = 0;
  1228. wpa_hexdump_ascii(MSG_DEBUG, "P2P: SD Request for UPnP",
  1229. query, query_len);
  1230. if (dl_list_empty(&wpa_s->global->p2p_srv_upnp)) {
  1231. wpa_printf(MSG_DEBUG, "P2P: UPnP protocol not available");
  1232. wpas_sd_add_proto_not_avail(resp, P2P_SERV_UPNP,
  1233. srv_trans_id);
  1234. return;
  1235. }
  1236. if (query_len == 0) {
  1237. wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
  1238. return;
  1239. }
  1240. if (wpabuf_tailroom(resp) < 5)
  1241. return;
  1242. /* Length (to be filled) */
  1243. len_pos = wpabuf_put(resp, 2);
  1244. wpabuf_put_u8(resp, P2P_SERV_UPNP);
  1245. wpabuf_put_u8(resp, srv_trans_id);
  1246. version = query[0];
  1247. str = os_malloc(query_len);
  1248. if (str == NULL)
  1249. return;
  1250. os_memcpy(str, query + 1, query_len - 1);
  1251. str[query_len - 1] = '\0';
  1252. dl_list_for_each(usrv, &wpa_s->global->p2p_srv_upnp,
  1253. struct p2p_srv_upnp, list) {
  1254. if (version != usrv->version)
  1255. continue;
  1256. if (os_strcmp(str, "ssdp:all") != 0 &&
  1257. os_strstr(usrv->service, str) == NULL)
  1258. continue;
  1259. if (wpabuf_tailroom(resp) < 2)
  1260. break;
  1261. if (count == 0) {
  1262. /* Status Code */
  1263. wpabuf_put_u8(resp, P2P_SD_SUCCESS);
  1264. /* Response Data */
  1265. wpabuf_put_u8(resp, version);
  1266. } else
  1267. wpabuf_put_u8(resp, ',');
  1268. count++;
  1269. wpa_printf(MSG_DEBUG, "P2P: Matching UPnP Service: %s",
  1270. usrv->service);
  1271. if (wpabuf_tailroom(resp) < os_strlen(usrv->service))
  1272. break;
  1273. wpabuf_put_str(resp, usrv->service);
  1274. }
  1275. os_free(str);
  1276. if (count == 0) {
  1277. wpa_printf(MSG_DEBUG, "P2P: Requested UPnP service not "
  1278. "available");
  1279. /* Status Code */
  1280. wpabuf_put_u8(resp, P2P_SD_REQUESTED_INFO_NOT_AVAILABLE);
  1281. /* Response Data: empty */
  1282. }
  1283. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
  1284. }
  1285. #ifdef CONFIG_WIFI_DISPLAY
  1286. static void wpas_sd_req_wfd(struct wpa_supplicant *wpa_s,
  1287. struct wpabuf *resp, u8 srv_trans_id,
  1288. const u8 *query, size_t query_len)
  1289. {
  1290. const u8 *pos;
  1291. u8 role;
  1292. u8 *len_pos;
  1293. wpa_hexdump(MSG_DEBUG, "P2P: SD Request for WFD", query, query_len);
  1294. if (!wpa_s->global->wifi_display) {
  1295. wpa_printf(MSG_DEBUG, "P2P: WFD protocol not available");
  1296. wpas_sd_add_proto_not_avail(resp, P2P_SERV_WIFI_DISPLAY,
  1297. srv_trans_id);
  1298. return;
  1299. }
  1300. if (query_len < 1) {
  1301. wpa_printf(MSG_DEBUG, "P2P: Missing WFD Requested Device "
  1302. "Role");
  1303. return;
  1304. }
  1305. if (wpabuf_tailroom(resp) < 5)
  1306. return;
  1307. pos = query;
  1308. role = *pos++;
  1309. wpa_printf(MSG_DEBUG, "P2P: WSD for device role 0x%x", role);
  1310. /* TODO: role specific handling */
  1311. /* Length (to be filled) */
  1312. len_pos = wpabuf_put(resp, 2);
  1313. wpabuf_put_u8(resp, P2P_SERV_WIFI_DISPLAY);
  1314. wpabuf_put_u8(resp, srv_trans_id);
  1315. wpabuf_put_u8(resp, P2P_SD_SUCCESS); /* Status Code */
  1316. while (pos < query + query_len) {
  1317. if (*pos < MAX_WFD_SUBELEMS &&
  1318. wpa_s->global->wfd_subelem[*pos] &&
  1319. wpabuf_tailroom(resp) >=
  1320. wpabuf_len(wpa_s->global->wfd_subelem[*pos])) {
  1321. wpa_printf(MSG_DEBUG, "P2P: Add WSD response "
  1322. "subelement %u", *pos);
  1323. wpabuf_put_buf(resp, wpa_s->global->wfd_subelem[*pos]);
  1324. }
  1325. pos++;
  1326. }
  1327. WPA_PUT_LE16(len_pos, (u8 *) wpabuf_put(resp, 0) - len_pos - 2);
  1328. }
  1329. #endif /* CONFIG_WIFI_DISPLAY */
  1330. void wpas_sd_request(void *ctx, int freq, const u8 *sa, u8 dialog_token,
  1331. u16 update_indic, const u8 *tlvs, size_t tlvs_len)
  1332. {
  1333. struct wpa_supplicant *wpa_s = ctx;
  1334. const u8 *pos = tlvs;
  1335. const u8 *end = tlvs + tlvs_len;
  1336. const u8 *tlv_end;
  1337. u16 slen;
  1338. struct wpabuf *resp;
  1339. u8 srv_proto, srv_trans_id;
  1340. size_t buf_len;
  1341. char *buf;
  1342. wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Request TLVs",
  1343. tlvs, tlvs_len);
  1344. buf_len = 2 * tlvs_len + 1;
  1345. buf = os_malloc(buf_len);
  1346. if (buf) {
  1347. wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len);
  1348. wpa_msg_ctrl(wpa_s, MSG_INFO, P2P_EVENT_SERV_DISC_REQ "%d "
  1349. MACSTR " %u %u %s",
  1350. freq, MAC2STR(sa), dialog_token, update_indic,
  1351. buf);
  1352. os_free(buf);
  1353. }
  1354. if (wpa_s->p2p_sd_over_ctrl_iface) {
  1355. wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token,
  1356. update_indic, tlvs, tlvs_len);
  1357. return; /* to be processed by an external program */
  1358. }
  1359. resp = wpabuf_alloc(10000);
  1360. if (resp == NULL)
  1361. return;
  1362. while (pos + 1 < end) {
  1363. wpa_printf(MSG_DEBUG, "P2P: Service Request TLV");
  1364. slen = WPA_GET_LE16(pos);
  1365. pos += 2;
  1366. if (pos + slen > end || slen < 2) {
  1367. wpa_printf(MSG_DEBUG, "P2P: Unexpected Query Data "
  1368. "length");
  1369. wpabuf_free(resp);
  1370. return;
  1371. }
  1372. tlv_end = pos + slen;
  1373. srv_proto = *pos++;
  1374. wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u",
  1375. srv_proto);
  1376. srv_trans_id = *pos++;
  1377. wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u",
  1378. srv_trans_id);
  1379. wpa_hexdump(MSG_MSGDUMP, "P2P: Query Data",
  1380. pos, tlv_end - pos);
  1381. if (wpa_s->force_long_sd) {
  1382. wpa_printf(MSG_DEBUG, "P2P: SD test - force long "
  1383. "response");
  1384. wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
  1385. wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
  1386. goto done;
  1387. }
  1388. switch (srv_proto) {
  1389. case P2P_SERV_ALL_SERVICES:
  1390. wpa_printf(MSG_DEBUG, "P2P: Service Discovery Request "
  1391. "for all services");
  1392. if (dl_list_empty(&wpa_s->global->p2p_srv_upnp) &&
  1393. dl_list_empty(&wpa_s->global->p2p_srv_bonjour)) {
  1394. wpa_printf(MSG_DEBUG, "P2P: No service "
  1395. "discovery protocols available");
  1396. wpas_sd_add_proto_not_avail(
  1397. resp, P2P_SERV_ALL_SERVICES,
  1398. srv_trans_id);
  1399. break;
  1400. }
  1401. wpas_sd_all_bonjour(wpa_s, resp, srv_trans_id);
  1402. wpas_sd_all_upnp(wpa_s, resp, srv_trans_id);
  1403. break;
  1404. case P2P_SERV_BONJOUR:
  1405. wpas_sd_req_bonjour(wpa_s, resp, srv_trans_id,
  1406. pos, tlv_end - pos);
  1407. break;
  1408. case P2P_SERV_UPNP:
  1409. wpas_sd_req_upnp(wpa_s, resp, srv_trans_id,
  1410. pos, tlv_end - pos);
  1411. break;
  1412. #ifdef CONFIG_WIFI_DISPLAY
  1413. case P2P_SERV_WIFI_DISPLAY:
  1414. wpas_sd_req_wfd(wpa_s, resp, srv_trans_id,
  1415. pos, tlv_end - pos);
  1416. break;
  1417. #endif /* CONFIG_WIFI_DISPLAY */
  1418. default:
  1419. wpa_printf(MSG_DEBUG, "P2P: Unavailable service "
  1420. "protocol %u", srv_proto);
  1421. wpas_sd_add_proto_not_avail(resp, srv_proto,
  1422. srv_trans_id);
  1423. break;
  1424. }
  1425. pos = tlv_end;
  1426. }
  1427. done:
  1428. wpas_notify_p2p_sd_request(wpa_s, freq, sa, dialog_token,
  1429. update_indic, tlvs, tlvs_len);
  1430. wpas_p2p_sd_response(wpa_s, freq, sa, dialog_token, resp);
  1431. wpabuf_free(resp);
  1432. }
  1433. void wpas_sd_response(void *ctx, const u8 *sa, u16 update_indic,
  1434. const u8 *tlvs, size_t tlvs_len)
  1435. {
  1436. struct wpa_supplicant *wpa_s = ctx;
  1437. const u8 *pos = tlvs;
  1438. const u8 *end = tlvs + tlvs_len;
  1439. const u8 *tlv_end;
  1440. u16 slen;
  1441. size_t buf_len;
  1442. char *buf;
  1443. wpa_hexdump(MSG_MSGDUMP, "P2P: Service Discovery Response TLVs",
  1444. tlvs, tlvs_len);
  1445. if (tlvs_len > 1500) {
  1446. /* TODO: better way for handling this */
  1447. wpa_msg_ctrl(wpa_s, MSG_INFO,
  1448. P2P_EVENT_SERV_DISC_RESP MACSTR
  1449. " %u <long response: %u bytes>",
  1450. MAC2STR(sa), update_indic,
  1451. (unsigned int) tlvs_len);
  1452. } else {
  1453. buf_len = 2 * tlvs_len + 1;
  1454. buf = os_malloc(buf_len);
  1455. if (buf) {
  1456. wpa_snprintf_hex(buf, buf_len, tlvs, tlvs_len);
  1457. wpa_msg_ctrl(wpa_s, MSG_INFO,
  1458. P2P_EVENT_SERV_DISC_RESP MACSTR " %u %s",
  1459. MAC2STR(sa), update_indic, buf);
  1460. os_free(buf);
  1461. }
  1462. }
  1463. while (pos < end) {
  1464. u8 srv_proto, srv_trans_id, status;
  1465. wpa_printf(MSG_DEBUG, "P2P: Service Response TLV");
  1466. slen = WPA_GET_LE16(pos);
  1467. pos += 2;
  1468. if (pos + slen > end || slen < 3) {
  1469. wpa_printf(MSG_DEBUG, "P2P: Unexpected Response Data "
  1470. "length");
  1471. return;
  1472. }
  1473. tlv_end = pos + slen;
  1474. srv_proto = *pos++;
  1475. wpa_printf(MSG_DEBUG, "P2P: Service Protocol Type %u",
  1476. srv_proto);
  1477. srv_trans_id = *pos++;
  1478. wpa_printf(MSG_DEBUG, "P2P: Service Transaction ID %u",
  1479. srv_trans_id);
  1480. status = *pos++;
  1481. wpa_printf(MSG_DEBUG, "P2P: Status Code ID %u",
  1482. status);
  1483. wpa_hexdump(MSG_MSGDUMP, "P2P: Response Data",
  1484. pos, tlv_end - pos);
  1485. pos = tlv_end;
  1486. }
  1487. wpas_notify_p2p_sd_response(wpa_s, sa, update_indic, tlvs, tlvs_len);
  1488. }
  1489. u64 wpas_p2p_sd_request(struct wpa_supplicant *wpa_s, const u8 *dst,
  1490. const struct wpabuf *tlvs)
  1491. {
  1492. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  1493. return wpa_drv_p2p_sd_request(wpa_s, dst, tlvs);
  1494. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  1495. return 0;
  1496. return (uintptr_t) p2p_sd_request(wpa_s->global->p2p, dst, tlvs);
  1497. }
  1498. u64 wpas_p2p_sd_request_upnp(struct wpa_supplicant *wpa_s, const u8 *dst,
  1499. u8 version, const char *query)
  1500. {
  1501. struct wpabuf *tlvs;
  1502. u64 ret;
  1503. tlvs = wpabuf_alloc(2 + 1 + 1 + 1 + os_strlen(query));
  1504. if (tlvs == NULL)
  1505. return 0;
  1506. wpabuf_put_le16(tlvs, 1 + 1 + 1 + os_strlen(query));
  1507. wpabuf_put_u8(tlvs, P2P_SERV_UPNP); /* Service Protocol Type */
  1508. wpabuf_put_u8(tlvs, 1); /* Service Transaction ID */
  1509. wpabuf_put_u8(tlvs, version);
  1510. wpabuf_put_str(tlvs, query);
  1511. ret = wpas_p2p_sd_request(wpa_s, dst, tlvs);
  1512. wpabuf_free(tlvs);
  1513. return ret;
  1514. }
  1515. #ifdef CONFIG_WIFI_DISPLAY
  1516. static u64 wpas_p2p_sd_request_wfd(struct wpa_supplicant *wpa_s, const u8 *dst,
  1517. const struct wpabuf *tlvs)
  1518. {
  1519. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  1520. return 0;
  1521. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  1522. return 0;
  1523. return (uintptr_t) p2p_sd_request_wfd(wpa_s->global->p2p, dst, tlvs);
  1524. }
  1525. #define MAX_WFD_SD_SUBELEMS 20
  1526. static void wfd_add_sd_req_role(struct wpabuf *tlvs, u8 id, u8 role,
  1527. const char *subelems)
  1528. {
  1529. u8 *len;
  1530. const char *pos;
  1531. int val;
  1532. int count = 0;
  1533. len = wpabuf_put(tlvs, 2);
  1534. wpabuf_put_u8(tlvs, P2P_SERV_WIFI_DISPLAY); /* Service Protocol Type */
  1535. wpabuf_put_u8(tlvs, id); /* Service Transaction ID */
  1536. wpabuf_put_u8(tlvs, role);
  1537. pos = subelems;
  1538. while (*pos) {
  1539. val = atoi(pos);
  1540. if (val >= 0 && val < 256) {
  1541. wpabuf_put_u8(tlvs, val);
  1542. count++;
  1543. if (count == MAX_WFD_SD_SUBELEMS)
  1544. break;
  1545. }
  1546. pos = os_strchr(pos + 1, ',');
  1547. if (pos == NULL)
  1548. break;
  1549. pos++;
  1550. }
  1551. WPA_PUT_LE16(len, (u8 *) wpabuf_put(tlvs, 0) - len - 2);
  1552. }
  1553. u64 wpas_p2p_sd_request_wifi_display(struct wpa_supplicant *wpa_s,
  1554. const u8 *dst, const char *role)
  1555. {
  1556. struct wpabuf *tlvs;
  1557. u64 ret;
  1558. const char *subelems;
  1559. u8 id = 1;
  1560. subelems = os_strchr(role, ' ');
  1561. if (subelems == NULL)
  1562. return 0;
  1563. subelems++;
  1564. tlvs = wpabuf_alloc(4 * (2 + 1 + 1 + 1 + MAX_WFD_SD_SUBELEMS));
  1565. if (tlvs == NULL)
  1566. return 0;
  1567. if (os_strstr(role, "[source]"))
  1568. wfd_add_sd_req_role(tlvs, id++, 0x00, subelems);
  1569. if (os_strstr(role, "[pri-sink]"))
  1570. wfd_add_sd_req_role(tlvs, id++, 0x01, subelems);
  1571. if (os_strstr(role, "[sec-sink]"))
  1572. wfd_add_sd_req_role(tlvs, id++, 0x02, subelems);
  1573. if (os_strstr(role, "[source+sink]"))
  1574. wfd_add_sd_req_role(tlvs, id++, 0x03, subelems);
  1575. ret = wpas_p2p_sd_request_wfd(wpa_s, dst, tlvs);
  1576. wpabuf_free(tlvs);
  1577. return ret;
  1578. }
  1579. #endif /* CONFIG_WIFI_DISPLAY */
  1580. int wpas_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s, u64 req)
  1581. {
  1582. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  1583. return wpa_drv_p2p_sd_cancel_request(wpa_s, req);
  1584. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  1585. return -1;
  1586. return p2p_sd_cancel_request(wpa_s->global->p2p,
  1587. (void *) (uintptr_t) req);
  1588. }
  1589. void wpas_p2p_sd_response(struct wpa_supplicant *wpa_s, int freq,
  1590. const u8 *dst, u8 dialog_token,
  1591. const struct wpabuf *resp_tlvs)
  1592. {
  1593. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
  1594. wpa_drv_p2p_sd_response(wpa_s, freq, dst, dialog_token,
  1595. resp_tlvs);
  1596. return;
  1597. }
  1598. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  1599. return;
  1600. p2p_sd_response(wpa_s->global->p2p, freq, dst, dialog_token,
  1601. resp_tlvs);
  1602. }
  1603. void wpas_p2p_sd_service_update(struct wpa_supplicant *wpa_s)
  1604. {
  1605. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
  1606. wpa_drv_p2p_service_update(wpa_s);
  1607. return;
  1608. }
  1609. if (wpa_s->global->p2p)
  1610. p2p_sd_service_update(wpa_s->global->p2p);
  1611. }
  1612. static void wpas_p2p_srv_bonjour_free(struct p2p_srv_bonjour *bsrv)
  1613. {
  1614. dl_list_del(&bsrv->list);
  1615. wpabuf_free(bsrv->query);
  1616. wpabuf_free(bsrv->resp);
  1617. os_free(bsrv);
  1618. }
  1619. static void wpas_p2p_srv_upnp_free(struct p2p_srv_upnp *usrv)
  1620. {
  1621. dl_list_del(&usrv->list);
  1622. os_free(usrv->service);
  1623. os_free(usrv);
  1624. }
  1625. void wpas_p2p_service_flush(struct wpa_supplicant *wpa_s)
  1626. {
  1627. struct p2p_srv_bonjour *bsrv, *bn;
  1628. struct p2p_srv_upnp *usrv, *un;
  1629. dl_list_for_each_safe(bsrv, bn, &wpa_s->global->p2p_srv_bonjour,
  1630. struct p2p_srv_bonjour, list)
  1631. wpas_p2p_srv_bonjour_free(bsrv);
  1632. dl_list_for_each_safe(usrv, un, &wpa_s->global->p2p_srv_upnp,
  1633. struct p2p_srv_upnp, list)
  1634. wpas_p2p_srv_upnp_free(usrv);
  1635. wpas_p2p_sd_service_update(wpa_s);
  1636. }
  1637. int wpas_p2p_service_add_bonjour(struct wpa_supplicant *wpa_s,
  1638. struct wpabuf *query, struct wpabuf *resp)
  1639. {
  1640. struct p2p_srv_bonjour *bsrv;
  1641. bsrv = wpas_p2p_service_get_bonjour(wpa_s, query);
  1642. if (bsrv) {
  1643. wpabuf_free(query);
  1644. wpabuf_free(bsrv->resp);
  1645. bsrv->resp = resp;
  1646. return 0;
  1647. }
  1648. bsrv = os_zalloc(sizeof(*bsrv));
  1649. if (bsrv == NULL)
  1650. return -1;
  1651. bsrv->query = query;
  1652. bsrv->resp = resp;
  1653. dl_list_add(&wpa_s->global->p2p_srv_bonjour, &bsrv->list);
  1654. wpas_p2p_sd_service_update(wpa_s);
  1655. return 0;
  1656. }
  1657. int wpas_p2p_service_del_bonjour(struct wpa_supplicant *wpa_s,
  1658. const struct wpabuf *query)
  1659. {
  1660. struct p2p_srv_bonjour *bsrv;
  1661. bsrv = wpas_p2p_service_get_bonjour(wpa_s, query);
  1662. if (bsrv == NULL)
  1663. return -1;
  1664. wpas_p2p_srv_bonjour_free(bsrv);
  1665. wpas_p2p_sd_service_update(wpa_s);
  1666. return 0;
  1667. }
  1668. int wpas_p2p_service_add_upnp(struct wpa_supplicant *wpa_s, u8 version,
  1669. const char *service)
  1670. {
  1671. struct p2p_srv_upnp *usrv;
  1672. if (wpas_p2p_service_get_upnp(wpa_s, version, service))
  1673. return 0; /* Already listed */
  1674. usrv = os_zalloc(sizeof(*usrv));
  1675. if (usrv == NULL)
  1676. return -1;
  1677. usrv->version = version;
  1678. usrv->service = os_strdup(service);
  1679. if (usrv->service == NULL) {
  1680. os_free(usrv);
  1681. return -1;
  1682. }
  1683. dl_list_add(&wpa_s->global->p2p_srv_upnp, &usrv->list);
  1684. wpas_p2p_sd_service_update(wpa_s);
  1685. return 0;
  1686. }
  1687. int wpas_p2p_service_del_upnp(struct wpa_supplicant *wpa_s, u8 version,
  1688. const char *service)
  1689. {
  1690. struct p2p_srv_upnp *usrv;
  1691. usrv = wpas_p2p_service_get_upnp(wpa_s, version, service);
  1692. if (usrv == NULL)
  1693. return -1;
  1694. wpas_p2p_srv_upnp_free(usrv);
  1695. wpas_p2p_sd_service_update(wpa_s);
  1696. return 0;
  1697. }
  1698. static void wpas_prov_disc_local_display(struct wpa_supplicant *wpa_s,
  1699. const u8 *peer, const char *params,
  1700. unsigned int generated_pin)
  1701. {
  1702. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_SHOW_PIN MACSTR " %08d%s",
  1703. MAC2STR(peer), generated_pin, params);
  1704. }
  1705. static void wpas_prov_disc_local_keypad(struct wpa_supplicant *wpa_s,
  1706. const u8 *peer, const char *params)
  1707. {
  1708. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_ENTER_PIN MACSTR "%s",
  1709. MAC2STR(peer), params);
  1710. }
  1711. void wpas_prov_disc_req(void *ctx, const u8 *peer, u16 config_methods,
  1712. const u8 *dev_addr, const u8 *pri_dev_type,
  1713. const char *dev_name, u16 supp_config_methods,
  1714. u8 dev_capab, u8 group_capab, const u8 *group_id,
  1715. size_t group_id_len)
  1716. {
  1717. struct wpa_supplicant *wpa_s = ctx;
  1718. char devtype[WPS_DEV_TYPE_BUFSIZE];
  1719. char params[300];
  1720. u8 empty_dev_type[8];
  1721. unsigned int generated_pin = 0;
  1722. struct wpa_supplicant *group = NULL;
  1723. if (group_id) {
  1724. for (group = wpa_s->global->ifaces; group; group = group->next)
  1725. {
  1726. struct wpa_ssid *s = group->current_ssid;
  1727. if (s != NULL &&
  1728. s->mode == WPAS_MODE_P2P_GO &&
  1729. group_id_len - ETH_ALEN == s->ssid_len &&
  1730. os_memcmp(group_id + ETH_ALEN, s->ssid,
  1731. s->ssid_len) == 0)
  1732. break;
  1733. }
  1734. }
  1735. if (pri_dev_type == NULL) {
  1736. os_memset(empty_dev_type, 0, sizeof(empty_dev_type));
  1737. pri_dev_type = empty_dev_type;
  1738. }
  1739. os_snprintf(params, sizeof(params), " p2p_dev_addr=" MACSTR
  1740. " pri_dev_type=%s name='%s' config_methods=0x%x "
  1741. "dev_capab=0x%x group_capab=0x%x%s%s",
  1742. MAC2STR(dev_addr),
  1743. wps_dev_type_bin2str(pri_dev_type, devtype,
  1744. sizeof(devtype)),
  1745. dev_name, supp_config_methods, dev_capab, group_capab,
  1746. group ? " group=" : "",
  1747. group ? group->ifname : "");
  1748. params[sizeof(params) - 1] = '\0';
  1749. if (config_methods & WPS_CONFIG_DISPLAY) {
  1750. generated_pin = wps_generate_pin();
  1751. wpas_prov_disc_local_display(wpa_s, peer, params,
  1752. generated_pin);
  1753. } else if (config_methods & WPS_CONFIG_KEYPAD)
  1754. wpas_prov_disc_local_keypad(wpa_s, peer, params);
  1755. else if (config_methods & WPS_CONFIG_PUSHBUTTON)
  1756. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_REQ MACSTR
  1757. "%s", MAC2STR(peer), params);
  1758. wpas_notify_p2p_provision_discovery(wpa_s, peer, 1 /* request */,
  1759. P2P_PROV_DISC_SUCCESS,
  1760. config_methods, generated_pin);
  1761. }
  1762. void wpas_prov_disc_resp(void *ctx, const u8 *peer, u16 config_methods)
  1763. {
  1764. struct wpa_supplicant *wpa_s = ctx;
  1765. unsigned int generated_pin = 0;
  1766. char params[20];
  1767. if (wpa_s->pending_pd_before_join &&
  1768. (os_memcmp(peer, wpa_s->pending_join_dev_addr, ETH_ALEN) == 0 ||
  1769. os_memcmp(peer, wpa_s->pending_join_iface_addr, ETH_ALEN) == 0)) {
  1770. wpa_s->pending_pd_before_join = 0;
  1771. wpa_printf(MSG_DEBUG, "P2P: Starting pending "
  1772. "join-existing-group operation");
  1773. wpas_p2p_join_start(wpa_s);
  1774. return;
  1775. }
  1776. if (wpa_s->pending_pd_use == AUTO_PD_JOIN ||
  1777. wpa_s->pending_pd_use == AUTO_PD_GO_NEG)
  1778. os_snprintf(params, sizeof(params), " peer_go=%d",
  1779. wpa_s->pending_pd_use == AUTO_PD_JOIN);
  1780. else
  1781. params[0] = '\0';
  1782. if (config_methods & WPS_CONFIG_DISPLAY)
  1783. wpas_prov_disc_local_keypad(wpa_s, peer, params);
  1784. else if (config_methods & WPS_CONFIG_KEYPAD) {
  1785. generated_pin = wps_generate_pin();
  1786. wpas_prov_disc_local_display(wpa_s, peer, params,
  1787. generated_pin);
  1788. } else if (config_methods & WPS_CONFIG_PUSHBUTTON)
  1789. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_PBC_RESP MACSTR
  1790. "%s", MAC2STR(peer), params);
  1791. wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
  1792. P2P_PROV_DISC_SUCCESS,
  1793. config_methods, generated_pin);
  1794. }
  1795. static void wpas_prov_disc_fail(void *ctx, const u8 *peer,
  1796. enum p2p_prov_disc_status status)
  1797. {
  1798. struct wpa_supplicant *wpa_s = ctx;
  1799. if (wpa_s->p2p_fallback_to_go_neg) {
  1800. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: PD for p2p_connect-auto "
  1801. "failed - fall back to GO Negotiation");
  1802. wpas_p2p_fallback_to_go_neg(wpa_s, 0);
  1803. return;
  1804. }
  1805. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
  1806. " p2p_dev_addr=" MACSTR " status=%d",
  1807. MAC2STR(peer), status);
  1808. wpas_notify_p2p_provision_discovery(wpa_s, peer, 0 /* response */,
  1809. status, 0, 0);
  1810. }
  1811. static u8 wpas_invitation_process(void *ctx, const u8 *sa, const u8 *bssid,
  1812. const u8 *go_dev_addr, const u8 *ssid,
  1813. size_t ssid_len, int *go, u8 *group_bssid,
  1814. int *force_freq, int persistent_group)
  1815. {
  1816. struct wpa_supplicant *wpa_s = ctx;
  1817. struct wpa_ssid *s;
  1818. u8 cur_bssid[ETH_ALEN];
  1819. int res;
  1820. struct wpa_supplicant *grp;
  1821. if (!persistent_group) {
  1822. wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
  1823. " to join an active group", MAC2STR(sa));
  1824. if (!is_zero_ether_addr(wpa_s->p2p_auth_invite) &&
  1825. (os_memcmp(go_dev_addr, wpa_s->p2p_auth_invite, ETH_ALEN)
  1826. == 0 ||
  1827. os_memcmp(sa, wpa_s->p2p_auth_invite, ETH_ALEN) == 0)) {
  1828. wpa_printf(MSG_DEBUG, "P2P: Accept previously "
  1829. "authorized invitation");
  1830. goto accept_inv;
  1831. }
  1832. /*
  1833. * Do not accept the invitation automatically; notify user and
  1834. * request approval.
  1835. */
  1836. return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
  1837. }
  1838. grp = wpas_get_p2p_group(wpa_s, ssid, ssid_len, go);
  1839. if (grp) {
  1840. wpa_printf(MSG_DEBUG, "P2P: Accept invitation to already "
  1841. "running persistent group");
  1842. if (*go)
  1843. os_memcpy(group_bssid, grp->own_addr, ETH_ALEN);
  1844. goto accept_inv;
  1845. }
  1846. if (!wpa_s->conf->persistent_reconnect)
  1847. return P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE;
  1848. for (s = wpa_s->conf->ssid; s; s = s->next) {
  1849. if (s->disabled == 2 &&
  1850. os_memcmp(s->bssid, go_dev_addr, ETH_ALEN) == 0 &&
  1851. s->ssid_len == ssid_len &&
  1852. os_memcmp(ssid, s->ssid, ssid_len) == 0)
  1853. break;
  1854. }
  1855. if (!s) {
  1856. wpa_printf(MSG_DEBUG, "P2P: Invitation from " MACSTR
  1857. " requested reinvocation of an unknown group",
  1858. MAC2STR(sa));
  1859. return P2P_SC_FAIL_UNKNOWN_GROUP;
  1860. }
  1861. if (s->mode == WPAS_MODE_P2P_GO && !wpas_p2p_create_iface(wpa_s)) {
  1862. *go = 1;
  1863. if (wpa_s->wpa_state >= WPA_AUTHENTICATING) {
  1864. wpa_printf(MSG_DEBUG, "P2P: The only available "
  1865. "interface is already in use - reject "
  1866. "invitation");
  1867. return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
  1868. }
  1869. os_memcpy(group_bssid, wpa_s->own_addr, ETH_ALEN);
  1870. } else if (s->mode == WPAS_MODE_P2P_GO) {
  1871. *go = 1;
  1872. if (wpas_p2p_add_group_interface(wpa_s, WPA_IF_P2P_GO) < 0)
  1873. {
  1874. wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
  1875. "interface address for the group");
  1876. return P2P_SC_FAIL_UNABLE_TO_ACCOMMODATE;
  1877. }
  1878. os_memcpy(group_bssid, wpa_s->pending_interface_addr,
  1879. ETH_ALEN);
  1880. }
  1881. accept_inv:
  1882. if (wpa_s->current_ssid && wpa_drv_get_bssid(wpa_s, cur_bssid) == 0 &&
  1883. wpa_s->assoc_freq) {
  1884. wpa_printf(MSG_DEBUG, "P2P: Trying to force channel to match "
  1885. "the channel we are already using");
  1886. *force_freq = wpa_s->assoc_freq;
  1887. }
  1888. res = wpa_drv_shared_freq(wpa_s);
  1889. if (res > 0) {
  1890. wpa_printf(MSG_DEBUG, "P2P: Trying to force channel to match "
  1891. "with the channel we are already using on a "
  1892. "shared interface");
  1893. *force_freq = res;
  1894. }
  1895. return P2P_SC_SUCCESS;
  1896. }
  1897. static void wpas_invitation_received(void *ctx, const u8 *sa, const u8 *bssid,
  1898. const u8 *ssid, size_t ssid_len,
  1899. const u8 *go_dev_addr, u8 status,
  1900. int op_freq)
  1901. {
  1902. struct wpa_supplicant *wpa_s = ctx;
  1903. struct wpa_ssid *s;
  1904. for (s = wpa_s->conf->ssid; s; s = s->next) {
  1905. if (s->disabled == 2 &&
  1906. s->ssid_len == ssid_len &&
  1907. os_memcmp(ssid, s->ssid, ssid_len) == 0)
  1908. break;
  1909. }
  1910. if (status == P2P_SC_SUCCESS) {
  1911. wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
  1912. " was accepted; op_freq=%d MHz",
  1913. MAC2STR(sa), op_freq);
  1914. if (s) {
  1915. int go = s->mode == WPAS_MODE_P2P_GO;
  1916. wpas_p2p_group_add_persistent(
  1917. wpa_s, s, go, go ? op_freq : 0, 0);
  1918. } else if (bssid) {
  1919. wpas_p2p_join(wpa_s, bssid, go_dev_addr,
  1920. wpa_s->p2p_wps_method, 0);
  1921. }
  1922. return;
  1923. }
  1924. if (status != P2P_SC_FAIL_INFO_CURRENTLY_UNAVAILABLE) {
  1925. wpa_printf(MSG_DEBUG, "P2P: Invitation from peer " MACSTR
  1926. " was rejected (status %u)", MAC2STR(sa), status);
  1927. return;
  1928. }
  1929. if (!s) {
  1930. if (bssid) {
  1931. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
  1932. "sa=" MACSTR " go_dev_addr=" MACSTR
  1933. " bssid=" MACSTR " unknown-network",
  1934. MAC2STR(sa), MAC2STR(go_dev_addr),
  1935. MAC2STR(bssid));
  1936. } else {
  1937. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED
  1938. "sa=" MACSTR " go_dev_addr=" MACSTR
  1939. " unknown-network",
  1940. MAC2STR(sa), MAC2STR(go_dev_addr));
  1941. }
  1942. return;
  1943. }
  1944. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RECEIVED "sa=" MACSTR
  1945. " persistent=%d", MAC2STR(sa), s->id);
  1946. }
  1947. static void wpas_invitation_result(void *ctx, int status, const u8 *bssid)
  1948. {
  1949. struct wpa_supplicant *wpa_s = ctx;
  1950. struct wpa_ssid *ssid;
  1951. if (bssid) {
  1952. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
  1953. "status=%d " MACSTR,
  1954. status, MAC2STR(bssid));
  1955. } else {
  1956. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_INVITATION_RESULT
  1957. "status=%d ", status);
  1958. }
  1959. wpas_notify_p2p_invitation_result(wpa_s, status, bssid);
  1960. if (wpa_s->pending_invite_ssid_id == -1)
  1961. return; /* Invitation to active group */
  1962. if (status != P2P_SC_SUCCESS) {
  1963. wpas_p2p_remove_pending_group_interface(wpa_s);
  1964. return;
  1965. }
  1966. ssid = wpa_config_get_network(wpa_s->conf,
  1967. wpa_s->pending_invite_ssid_id);
  1968. if (ssid == NULL) {
  1969. wpa_printf(MSG_ERROR, "P2P: Could not find persistent group "
  1970. "data matching with invitation");
  1971. return;
  1972. }
  1973. /*
  1974. * The peer could have missed our ctrl::ack frame for Invitation
  1975. * Response and continue retransmitting the frame. To reduce the
  1976. * likelihood of the peer not getting successful TX status for the
  1977. * Invitation Response frame, wait a short time here before starting
  1978. * the persistent group so that we will remain on the current channel to
  1979. * acknowledge any possible retransmission from the peer.
  1980. */
  1981. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: 50 ms wait on current channel before "
  1982. "starting persistent group");
  1983. os_sleep(0, 50000);
  1984. wpas_p2p_group_add_persistent(wpa_s, ssid,
  1985. ssid->mode == WPAS_MODE_P2P_GO,
  1986. wpa_s->p2p_persistent_go_freq,
  1987. wpa_s->p2p_go_ht40);
  1988. }
  1989. static int wpas_p2p_disallowed_freq(struct wpa_global *global,
  1990. unsigned int freq)
  1991. {
  1992. unsigned int i;
  1993. if (global->p2p_disallow_freq == NULL)
  1994. return 0;
  1995. for (i = 0; i < global->num_p2p_disallow_freq; i++) {
  1996. if (freq >= global->p2p_disallow_freq[i].min &&
  1997. freq <= global->p2p_disallow_freq[i].max)
  1998. return 1;
  1999. }
  2000. return 0;
  2001. }
  2002. static void wpas_p2p_add_chan(struct p2p_reg_class *reg, u8 chan)
  2003. {
  2004. reg->channel[reg->channels] = chan;
  2005. reg->channels++;
  2006. }
  2007. static int wpas_p2p_default_channels(struct wpa_supplicant *wpa_s,
  2008. struct p2p_channels *chan)
  2009. {
  2010. int i, cla = 0;
  2011. wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for 2.4 GHz "
  2012. "band");
  2013. /* Operating class 81 - 2.4 GHz band channels 1..13 */
  2014. chan->reg_class[cla].reg_class = 81;
  2015. chan->reg_class[cla].channels = 0;
  2016. for (i = 0; i < 11; i++) {
  2017. if (!wpas_p2p_disallowed_freq(wpa_s->global, 2412 + i * 5))
  2018. wpas_p2p_add_chan(&chan->reg_class[cla], i + 1);
  2019. }
  2020. if (chan->reg_class[cla].channels)
  2021. cla++;
  2022. wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for lower 5 GHz "
  2023. "band");
  2024. /* Operating class 115 - 5 GHz, channels 36-48 */
  2025. chan->reg_class[cla].reg_class = 115;
  2026. chan->reg_class[cla].channels = 0;
  2027. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 36 * 5))
  2028. wpas_p2p_add_chan(&chan->reg_class[cla], 36);
  2029. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 40 * 5))
  2030. wpas_p2p_add_chan(&chan->reg_class[cla], 40);
  2031. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 44 * 5))
  2032. wpas_p2p_add_chan(&chan->reg_class[cla], 44);
  2033. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 48 * 5))
  2034. wpas_p2p_add_chan(&chan->reg_class[cla], 48);
  2035. if (chan->reg_class[cla].channels)
  2036. cla++;
  2037. wpa_printf(MSG_DEBUG, "P2P: Enable operating classes for higher 5 GHz "
  2038. "band");
  2039. /* Operating class 124 - 5 GHz, channels 149,153,157,161 */
  2040. chan->reg_class[cla].reg_class = 124;
  2041. chan->reg_class[cla].channels = 0;
  2042. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 149 * 5))
  2043. wpas_p2p_add_chan(&chan->reg_class[cla], 149);
  2044. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 153 * 5))
  2045. wpas_p2p_add_chan(&chan->reg_class[cla], 153);
  2046. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 156 * 5))
  2047. wpas_p2p_add_chan(&chan->reg_class[cla], 157);
  2048. if (!wpas_p2p_disallowed_freq(wpa_s->global, 5000 + 161 * 5))
  2049. wpas_p2p_add_chan(&chan->reg_class[cla], 161);
  2050. if (chan->reg_class[cla].channels)
  2051. cla++;
  2052. chan->reg_classes = cla;
  2053. return 0;
  2054. }
  2055. static struct hostapd_hw_modes * get_mode(struct hostapd_hw_modes *modes,
  2056. u16 num_modes,
  2057. enum hostapd_hw_mode mode)
  2058. {
  2059. u16 i;
  2060. for (i = 0; i < num_modes; i++) {
  2061. if (modes[i].mode == mode)
  2062. return &modes[i];
  2063. }
  2064. return NULL;
  2065. }
  2066. static int has_channel(struct wpa_global *global,
  2067. struct hostapd_hw_modes *mode, u8 chan, int *flags)
  2068. {
  2069. int i;
  2070. unsigned int freq;
  2071. freq = (mode->mode == HOSTAPD_MODE_IEEE80211A ? 5000 : 2407) +
  2072. chan * 5;
  2073. if (wpas_p2p_disallowed_freq(global, freq))
  2074. return 0;
  2075. for (i = 0; i < mode->num_channels; i++) {
  2076. if (mode->channels[i].chan == chan) {
  2077. if (flags)
  2078. *flags = mode->channels[i].flag;
  2079. return !(mode->channels[i].flag &
  2080. (HOSTAPD_CHAN_DISABLED |
  2081. HOSTAPD_CHAN_PASSIVE_SCAN |
  2082. HOSTAPD_CHAN_NO_IBSS |
  2083. HOSTAPD_CHAN_RADAR));
  2084. }
  2085. }
  2086. return 0;
  2087. }
  2088. struct p2p_oper_class_map {
  2089. enum hostapd_hw_mode mode;
  2090. u8 op_class;
  2091. u8 min_chan;
  2092. u8 max_chan;
  2093. u8 inc;
  2094. enum { BW20, BW40PLUS, BW40MINUS } bw;
  2095. };
  2096. static struct p2p_oper_class_map op_class[] = {
  2097. { HOSTAPD_MODE_IEEE80211G, 81, 1, 13, 1, BW20 },
  2098. #if 0 /* Do not enable HT40 on 2 GHz for now */
  2099. { HOSTAPD_MODE_IEEE80211G, 83, 1, 9, 1, BW40PLUS },
  2100. { HOSTAPD_MODE_IEEE80211G, 84, 5, 13, 1, BW40MINUS },
  2101. #endif
  2102. { HOSTAPD_MODE_IEEE80211A, 115, 36, 48, 4, BW20 },
  2103. { HOSTAPD_MODE_IEEE80211A, 124, 149, 161, 4, BW20 },
  2104. { HOSTAPD_MODE_IEEE80211A, 116, 36, 44, 8, BW40PLUS },
  2105. { HOSTAPD_MODE_IEEE80211A, 117, 40, 48, 8, BW40MINUS },
  2106. { HOSTAPD_MODE_IEEE80211A, 126, 149, 157, 8, BW40PLUS },
  2107. { HOSTAPD_MODE_IEEE80211A, 127, 153, 161, 8, BW40MINUS },
  2108. { -1, 0, 0, 0, 0, BW20 }
  2109. };
  2110. static int wpas_p2p_verify_channel(struct wpa_supplicant *wpa_s,
  2111. struct hostapd_hw_modes *mode,
  2112. u8 channel, u8 bw)
  2113. {
  2114. int flag;
  2115. if (!has_channel(wpa_s->global, mode, channel, &flag))
  2116. return -1;
  2117. if (bw == BW40MINUS &&
  2118. (!(flag & HOSTAPD_CHAN_HT40MINUS) ||
  2119. !has_channel(wpa_s->global, mode, channel - 4, NULL)))
  2120. return 0;
  2121. if (bw == BW40PLUS &&
  2122. (!(flag & HOSTAPD_CHAN_HT40PLUS) ||
  2123. !has_channel(wpa_s->global, mode, channel + 4, NULL)))
  2124. return 0;
  2125. return 1;
  2126. }
  2127. static int wpas_p2p_setup_channels(struct wpa_supplicant *wpa_s,
  2128. struct p2p_channels *chan)
  2129. {
  2130. struct hostapd_hw_modes *mode;
  2131. int cla, op;
  2132. if (wpa_s->hw.modes == NULL) {
  2133. wpa_printf(MSG_DEBUG, "P2P: Driver did not support fetching "
  2134. "of all supported channels; assume dualband "
  2135. "support");
  2136. return wpas_p2p_default_channels(wpa_s, chan);
  2137. }
  2138. cla = 0;
  2139. for (op = 0; op_class[op].op_class; op++) {
  2140. struct p2p_oper_class_map *o = &op_class[op];
  2141. u8 ch;
  2142. struct p2p_reg_class *reg = NULL;
  2143. mode = get_mode(wpa_s->hw.modes, wpa_s->hw.num_modes, o->mode);
  2144. if (mode == NULL)
  2145. continue;
  2146. for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
  2147. if (wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw) < 1)
  2148. continue;
  2149. if (reg == NULL) {
  2150. wpa_printf(MSG_DEBUG, "P2P: Add operating "
  2151. "class %u", o->op_class);
  2152. reg = &chan->reg_class[cla];
  2153. cla++;
  2154. reg->reg_class = o->op_class;
  2155. }
  2156. reg->channel[reg->channels] = ch;
  2157. reg->channels++;
  2158. }
  2159. if (reg) {
  2160. wpa_hexdump(MSG_DEBUG, "P2P: Channels",
  2161. reg->channel, reg->channels);
  2162. }
  2163. }
  2164. chan->reg_classes = cla;
  2165. return 0;
  2166. }
  2167. int wpas_p2p_get_ht40_mode(struct wpa_supplicant *wpa_s,
  2168. struct hostapd_hw_modes *mode, u8 channel)
  2169. {
  2170. int op, ret;
  2171. for (op = 0; op_class[op].op_class; op++) {
  2172. struct p2p_oper_class_map *o = &op_class[op];
  2173. u8 ch;
  2174. for (ch = o->min_chan; ch <= o->max_chan; ch += o->inc) {
  2175. if (o->mode != HOSTAPD_MODE_IEEE80211A ||
  2176. o->bw == BW20 || ch != channel)
  2177. continue;
  2178. ret = wpas_p2p_verify_channel(wpa_s, mode, ch, o->bw);
  2179. if (ret < 0)
  2180. continue;
  2181. else if (ret > 0)
  2182. return (o->bw == BW40MINUS) ? -1 : 1;
  2183. else
  2184. return 0;
  2185. }
  2186. }
  2187. return 0;
  2188. }
  2189. static int wpas_get_noa(void *ctx, const u8 *interface_addr, u8 *buf,
  2190. size_t buf_len)
  2191. {
  2192. struct wpa_supplicant *wpa_s = ctx;
  2193. for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  2194. if (os_memcmp(wpa_s->own_addr, interface_addr, ETH_ALEN) == 0)
  2195. break;
  2196. }
  2197. if (wpa_s == NULL)
  2198. return -1;
  2199. return wpa_drv_get_noa(wpa_s, buf, buf_len);
  2200. }
  2201. static int wpas_go_connected(void *ctx, const u8 *dev_addr)
  2202. {
  2203. struct wpa_supplicant *wpa_s = ctx;
  2204. for (wpa_s = wpa_s->global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  2205. struct wpa_ssid *ssid = wpa_s->current_ssid;
  2206. if (ssid == NULL)
  2207. continue;
  2208. if (ssid->mode != WPAS_MODE_INFRA)
  2209. continue;
  2210. if (wpa_s->wpa_state != WPA_COMPLETED &&
  2211. wpa_s->wpa_state != WPA_GROUP_HANDSHAKE)
  2212. continue;
  2213. if (os_memcmp(wpa_s->go_dev_addr, dev_addr, ETH_ALEN) == 0)
  2214. return 1;
  2215. }
  2216. return 0;
  2217. }
  2218. /**
  2219. * wpas_p2p_init - Initialize P2P module for %wpa_supplicant
  2220. * @global: Pointer to global data from wpa_supplicant_init()
  2221. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  2222. * Returns: 0 on success, -1 on failure
  2223. */
  2224. int wpas_p2p_init(struct wpa_global *global, struct wpa_supplicant *wpa_s)
  2225. {
  2226. struct p2p_config p2p;
  2227. unsigned int r;
  2228. int i;
  2229. if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
  2230. return 0;
  2231. if (global->p2p)
  2232. return 0;
  2233. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
  2234. struct p2p_params params;
  2235. wpa_printf(MSG_DEBUG, "P2P: Use driver-based P2P management");
  2236. os_memset(&params, 0, sizeof(params));
  2237. params.dev_name = wpa_s->conf->device_name;
  2238. os_memcpy(params.pri_dev_type, wpa_s->conf->device_type,
  2239. WPS_DEV_TYPE_LEN);
  2240. params.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
  2241. os_memcpy(params.sec_dev_type,
  2242. wpa_s->conf->sec_device_type,
  2243. params.num_sec_dev_types * WPS_DEV_TYPE_LEN);
  2244. if (wpa_drv_p2p_set_params(wpa_s, &params) < 0)
  2245. return -1;
  2246. return 0;
  2247. }
  2248. os_memset(&p2p, 0, sizeof(p2p));
  2249. p2p.msg_ctx = wpa_s;
  2250. p2p.cb_ctx = wpa_s;
  2251. p2p.p2p_scan = wpas_p2p_scan;
  2252. p2p.send_action = wpas_send_action;
  2253. p2p.send_action_done = wpas_send_action_done;
  2254. p2p.go_neg_completed = wpas_go_neg_completed;
  2255. p2p.go_neg_req_rx = wpas_go_neg_req_rx;
  2256. p2p.dev_found = wpas_dev_found;
  2257. p2p.dev_lost = wpas_dev_lost;
  2258. p2p.start_listen = wpas_start_listen;
  2259. p2p.stop_listen = wpas_stop_listen;
  2260. p2p.send_probe_resp = wpas_send_probe_resp;
  2261. p2p.sd_request = wpas_sd_request;
  2262. p2p.sd_response = wpas_sd_response;
  2263. p2p.prov_disc_req = wpas_prov_disc_req;
  2264. p2p.prov_disc_resp = wpas_prov_disc_resp;
  2265. p2p.prov_disc_fail = wpas_prov_disc_fail;
  2266. p2p.invitation_process = wpas_invitation_process;
  2267. p2p.invitation_received = wpas_invitation_received;
  2268. p2p.invitation_result = wpas_invitation_result;
  2269. p2p.get_noa = wpas_get_noa;
  2270. p2p.go_connected = wpas_go_connected;
  2271. os_memcpy(wpa_s->global->p2p_dev_addr, wpa_s->own_addr, ETH_ALEN);
  2272. os_memcpy(p2p.dev_addr, wpa_s->global->p2p_dev_addr, ETH_ALEN);
  2273. p2p.dev_name = wpa_s->conf->device_name;
  2274. p2p.manufacturer = wpa_s->conf->manufacturer;
  2275. p2p.model_name = wpa_s->conf->model_name;
  2276. p2p.model_number = wpa_s->conf->model_number;
  2277. p2p.serial_number = wpa_s->conf->serial_number;
  2278. if (wpa_s->wps) {
  2279. os_memcpy(p2p.uuid, wpa_s->wps->uuid, 16);
  2280. p2p.config_methods = wpa_s->wps->config_methods;
  2281. }
  2282. if (wpa_s->conf->p2p_listen_reg_class &&
  2283. wpa_s->conf->p2p_listen_channel) {
  2284. p2p.reg_class = wpa_s->conf->p2p_listen_reg_class;
  2285. p2p.channel = wpa_s->conf->p2p_listen_channel;
  2286. } else {
  2287. p2p.reg_class = 81;
  2288. /*
  2289. * Pick one of the social channels randomly as the listen
  2290. * channel.
  2291. */
  2292. os_get_random((u8 *) &r, sizeof(r));
  2293. p2p.channel = 1 + (r % 3) * 5;
  2294. }
  2295. wpa_printf(MSG_DEBUG, "P2P: Own listen channel: %d", p2p.channel);
  2296. if (wpa_s->conf->p2p_oper_reg_class &&
  2297. wpa_s->conf->p2p_oper_channel) {
  2298. p2p.op_reg_class = wpa_s->conf->p2p_oper_reg_class;
  2299. p2p.op_channel = wpa_s->conf->p2p_oper_channel;
  2300. p2p.cfg_op_channel = 1;
  2301. wpa_printf(MSG_DEBUG, "P2P: Configured operating channel: "
  2302. "%d:%d", p2p.op_reg_class, p2p.op_channel);
  2303. } else {
  2304. p2p.op_reg_class = 81;
  2305. /*
  2306. * Use random operation channel from (1, 6, 11) if no other
  2307. * preference is indicated.
  2308. */
  2309. os_get_random((u8 *) &r, sizeof(r));
  2310. p2p.op_channel = 1 + (r % 3) * 5;
  2311. p2p.cfg_op_channel = 0;
  2312. wpa_printf(MSG_DEBUG, "P2P: Random operating channel: "
  2313. "%d:%d", p2p.op_reg_class, p2p.op_channel);
  2314. }
  2315. if (wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
  2316. os_memcpy(p2p.country, wpa_s->conf->country, 2);
  2317. p2p.country[2] = 0x04;
  2318. } else
  2319. os_memcpy(p2p.country, "XX\x04", 3);
  2320. if (wpas_p2p_setup_channels(wpa_s, &p2p.channels)) {
  2321. wpa_printf(MSG_ERROR, "P2P: Failed to configure supported "
  2322. "channel list");
  2323. return -1;
  2324. }
  2325. os_memcpy(p2p.pri_dev_type, wpa_s->conf->device_type,
  2326. WPS_DEV_TYPE_LEN);
  2327. p2p.num_sec_dev_types = wpa_s->conf->num_sec_device_types;
  2328. os_memcpy(p2p.sec_dev_type, wpa_s->conf->sec_device_type,
  2329. p2p.num_sec_dev_types * WPS_DEV_TYPE_LEN);
  2330. p2p.concurrent_operations = !!(wpa_s->drv_flags &
  2331. WPA_DRIVER_FLAGS_P2P_CONCURRENT);
  2332. p2p.max_peers = 100;
  2333. if (wpa_s->conf->p2p_ssid_postfix) {
  2334. p2p.ssid_postfix_len =
  2335. os_strlen(wpa_s->conf->p2p_ssid_postfix);
  2336. if (p2p.ssid_postfix_len > sizeof(p2p.ssid_postfix))
  2337. p2p.ssid_postfix_len = sizeof(p2p.ssid_postfix);
  2338. os_memcpy(p2p.ssid_postfix, wpa_s->conf->p2p_ssid_postfix,
  2339. p2p.ssid_postfix_len);
  2340. }
  2341. p2p.p2p_intra_bss = wpa_s->conf->p2p_intra_bss;
  2342. global->p2p = p2p_init(&p2p);
  2343. if (global->p2p == NULL)
  2344. return -1;
  2345. global->p2p_init_wpa_s = wpa_s;
  2346. for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) {
  2347. if (wpa_s->conf->wps_vendor_ext[i] == NULL)
  2348. continue;
  2349. p2p_add_wps_vendor_extension(
  2350. global->p2p, wpa_s->conf->wps_vendor_ext[i]);
  2351. }
  2352. return 0;
  2353. }
  2354. /**
  2355. * wpas_p2p_deinit - Deinitialize per-interface P2P data
  2356. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  2357. *
  2358. * This function deinitialize per-interface P2P data.
  2359. */
  2360. void wpas_p2p_deinit(struct wpa_supplicant *wpa_s)
  2361. {
  2362. if (wpa_s->driver && wpa_s->drv_priv)
  2363. wpa_drv_probe_req_report(wpa_s, 0);
  2364. if (wpa_s->go_params) {
  2365. /* Clear any stored provisioning info */
  2366. p2p_clear_provisioning_info(
  2367. wpa_s->global->p2p,
  2368. wpa_s->go_params->peer_device_addr);
  2369. }
  2370. os_free(wpa_s->go_params);
  2371. wpa_s->go_params = NULL;
  2372. eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
  2373. eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
  2374. eloop_cancel_timeout(wpas_p2p_pd_before_join_timeout, wpa_s, NULL);
  2375. wpa_s->p2p_long_listen = 0;
  2376. eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
  2377. eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
  2378. wpas_p2p_remove_pending_group_interface(wpa_s);
  2379. /* TODO: remove group interface from the driver if this wpa_s instance
  2380. * is on top of a P2P group interface */
  2381. }
  2382. /**
  2383. * wpas_p2p_deinit_global - Deinitialize global P2P module
  2384. * @global: Pointer to global data from wpa_supplicant_init()
  2385. *
  2386. * This function deinitializes the global (per device) P2P module.
  2387. */
  2388. void wpas_p2p_deinit_global(struct wpa_global *global)
  2389. {
  2390. struct wpa_supplicant *wpa_s, *tmp;
  2391. wpa_s = global->ifaces;
  2392. if (wpa_s)
  2393. wpas_p2p_service_flush(wpa_s);
  2394. if (global->p2p == NULL)
  2395. return;
  2396. /* Remove remaining P2P group interfaces */
  2397. while (wpa_s && wpa_s->p2p_group_interface != NOT_P2P_GROUP_INTERFACE)
  2398. wpa_s = wpa_s->next;
  2399. while (wpa_s) {
  2400. tmp = global->ifaces;
  2401. while (tmp &&
  2402. (tmp == wpa_s ||
  2403. tmp->p2p_group_interface == NOT_P2P_GROUP_INTERFACE)) {
  2404. tmp = tmp->next;
  2405. }
  2406. if (tmp == NULL)
  2407. break;
  2408. /* Disconnect from the P2P group and deinit the interface */
  2409. wpas_p2p_disconnect(tmp);
  2410. }
  2411. /*
  2412. * Deinit GO data on any possibly remaining interface (if main
  2413. * interface is used as GO).
  2414. */
  2415. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  2416. if (wpa_s->ap_iface)
  2417. wpas_p2p_group_deinit(wpa_s);
  2418. }
  2419. p2p_deinit(global->p2p);
  2420. global->p2p = NULL;
  2421. global->p2p_init_wpa_s = NULL;
  2422. }
  2423. static int wpas_p2p_create_iface(struct wpa_supplicant *wpa_s)
  2424. {
  2425. if (wpa_s->drv_flags &
  2426. (WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE |
  2427. WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P))
  2428. return 1; /* P2P group requires a new interface in every case
  2429. */
  2430. if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CONCURRENT))
  2431. return 0; /* driver does not support concurrent operations */
  2432. if (wpa_s->global->ifaces->next)
  2433. return 1; /* more that one interface already in use */
  2434. if (wpa_s->wpa_state >= WPA_AUTHENTICATING)
  2435. return 1; /* this interface is already in use */
  2436. return 0;
  2437. }
  2438. static int wpas_p2p_start_go_neg(struct wpa_supplicant *wpa_s,
  2439. const u8 *peer_addr,
  2440. enum p2p_wps_method wps_method,
  2441. int go_intent, const u8 *own_interface_addr,
  2442. unsigned int force_freq, int persistent_group,
  2443. struct wpa_ssid *ssid)
  2444. {
  2445. if (persistent_group && wpa_s->conf->persistent_reconnect)
  2446. persistent_group = 2;
  2447. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
  2448. return wpa_drv_p2p_connect(wpa_s, peer_addr, wps_method,
  2449. go_intent, own_interface_addr,
  2450. force_freq, persistent_group);
  2451. }
  2452. /*
  2453. * Increase GO config timeout if HT40 is used since it takes some time
  2454. * to scan channels for coex purposes before the BSS can be started.
  2455. */
  2456. p2p_set_config_timeout(wpa_s->global->p2p,
  2457. wpa_s->p2p_go_ht40 ? 255 : 100, 20);
  2458. return p2p_connect(wpa_s->global->p2p, peer_addr, wps_method,
  2459. go_intent, own_interface_addr, force_freq,
  2460. persistent_group, ssid ? ssid->ssid : NULL,
  2461. ssid ? ssid->ssid_len : 0,
  2462. wpa_s->p2p_pd_before_go_neg);
  2463. }
  2464. static int wpas_p2p_auth_go_neg(struct wpa_supplicant *wpa_s,
  2465. const u8 *peer_addr,
  2466. enum p2p_wps_method wps_method,
  2467. int go_intent, const u8 *own_interface_addr,
  2468. unsigned int force_freq, int persistent_group,
  2469. struct wpa_ssid *ssid)
  2470. {
  2471. if (persistent_group && wpa_s->conf->persistent_reconnect)
  2472. persistent_group = 2;
  2473. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  2474. return -1;
  2475. return p2p_authorize(wpa_s->global->p2p, peer_addr, wps_method,
  2476. go_intent, own_interface_addr, force_freq,
  2477. persistent_group, ssid ? ssid->ssid : NULL,
  2478. ssid ? ssid->ssid_len : 0);
  2479. }
  2480. static void wpas_p2p_check_join_scan_limit(struct wpa_supplicant *wpa_s)
  2481. {
  2482. wpa_s->p2p_join_scan_count++;
  2483. wpa_printf(MSG_DEBUG, "P2P: Join scan attempt %d",
  2484. wpa_s->p2p_join_scan_count);
  2485. if (wpa_s->p2p_join_scan_count > P2P_MAX_JOIN_SCAN_ATTEMPTS) {
  2486. wpa_printf(MSG_DEBUG, "P2P: Failed to find GO " MACSTR
  2487. " for join operationg - stop join attempt",
  2488. MAC2STR(wpa_s->pending_join_iface_addr));
  2489. eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
  2490. if (wpa_s->p2p_auto_pd) {
  2491. wpa_s->p2p_auto_pd = 0;
  2492. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
  2493. " p2p_dev_addr=" MACSTR " status=N/A",
  2494. MAC2STR(wpa_s->pending_join_dev_addr));
  2495. return;
  2496. }
  2497. wpa_msg(wpa_s->parent, MSG_INFO,
  2498. P2P_EVENT_GROUP_FORMATION_FAILURE);
  2499. }
  2500. }
  2501. static void wpas_p2p_pd_before_join_timeout(void *eloop_ctx, void *timeout_ctx)
  2502. {
  2503. struct wpa_supplicant *wpa_s = eloop_ctx;
  2504. if (!wpa_s->pending_pd_before_join)
  2505. return;
  2506. /*
  2507. * Provision Discovery Response may have been lost - try to connect
  2508. * anyway since we do not need any information from this PD.
  2509. */
  2510. wpa_printf(MSG_DEBUG, "P2P: PD timeout for join-existing-group - "
  2511. "try to connect anyway");
  2512. wpas_p2p_join_start(wpa_s);
  2513. }
  2514. static int wpas_check_freq_conflict(struct wpa_supplicant *wpa_s, int freq)
  2515. {
  2516. struct wpa_supplicant *iface;
  2517. int shared_freq;
  2518. u8 bssid[ETH_ALEN];
  2519. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_MULTI_CHANNEL_CONCURRENT)
  2520. return 0;
  2521. for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
  2522. if (!wpas_p2p_create_iface(wpa_s) && iface == wpa_s)
  2523. continue;
  2524. if (iface->current_ssid == NULL || iface->assoc_freq == 0)
  2525. continue;
  2526. if (iface->current_ssid->mode == WPAS_MODE_AP ||
  2527. iface->current_ssid->mode == WPAS_MODE_P2P_GO)
  2528. shared_freq = iface->current_ssid->frequency;
  2529. else if (wpa_drv_get_bssid(iface, bssid) == 0)
  2530. shared_freq = iface->assoc_freq;
  2531. else
  2532. shared_freq = 0;
  2533. if (shared_freq && freq != shared_freq) {
  2534. wpa_printf(MSG_DEBUG, "P2P: Frequency conflict - %s "
  2535. "connected on %d MHz - new connection on "
  2536. "%d MHz", iface->ifname, shared_freq, freq);
  2537. return 1;
  2538. }
  2539. }
  2540. shared_freq = wpa_drv_shared_freq(wpa_s);
  2541. if (shared_freq > 0 && shared_freq != freq) {
  2542. wpa_printf(MSG_DEBUG, "P2P: Frequency conflict - shared "
  2543. "virtual interface connected on %d MHz - new "
  2544. "connection on %d MHz", shared_freq, freq);
  2545. return 1;
  2546. }
  2547. return 0;
  2548. }
  2549. static int wpas_p2p_peer_go(struct wpa_supplicant *wpa_s,
  2550. const u8 *peer_dev_addr)
  2551. {
  2552. struct wpa_bss *bss;
  2553. int updated;
  2554. bss = wpa_bss_get_p2p_dev_addr(wpa_s, peer_dev_addr);
  2555. if (bss == NULL)
  2556. return -1;
  2557. if (bss->last_update_idx < wpa_s->bss_update_idx) {
  2558. wpa_printf(MSG_DEBUG, "P2P: Peer BSS entry not updated in the "
  2559. "last scan");
  2560. return 0;
  2561. }
  2562. updated = os_time_before(&wpa_s->p2p_auto_started, &bss->last_update);
  2563. wpa_printf(MSG_DEBUG, "P2P: Current BSS entry for peer updated at "
  2564. "%ld.%06ld (%supdated in last scan)",
  2565. bss->last_update.sec, bss->last_update.usec,
  2566. updated ? "": "not ");
  2567. return updated;
  2568. }
  2569. static void wpas_p2p_scan_res_join(struct wpa_supplicant *wpa_s,
  2570. struct wpa_scan_results *scan_res)
  2571. {
  2572. struct wpa_bss *bss;
  2573. int freq;
  2574. u8 iface_addr[ETH_ALEN];
  2575. eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
  2576. if (wpa_s->global->p2p_disabled)
  2577. return;
  2578. wpa_printf(MSG_DEBUG, "P2P: Scan results received (%d BSS) for %sjoin",
  2579. scan_res ? (int) scan_res->num : -1,
  2580. wpa_s->p2p_auto_join ? "auto_" : "");
  2581. if (scan_res)
  2582. wpas_p2p_scan_res_handler(wpa_s, scan_res);
  2583. if (wpa_s->p2p_auto_pd) {
  2584. int join = wpas_p2p_peer_go(wpa_s,
  2585. wpa_s->pending_join_dev_addr);
  2586. if (join == 0 &&
  2587. wpa_s->auto_pd_scan_retry < P2P_AUTO_PD_SCAN_ATTEMPTS) {
  2588. wpa_s->auto_pd_scan_retry++;
  2589. bss = wpa_bss_get_bssid(wpa_s,
  2590. wpa_s->pending_join_dev_addr);
  2591. if (bss) {
  2592. freq = bss->freq;
  2593. wpa_printf(MSG_DEBUG, "P2P: Scan retry %d for "
  2594. "the peer " MACSTR " at %d MHz",
  2595. wpa_s->auto_pd_scan_retry,
  2596. MAC2STR(wpa_s->
  2597. pending_join_dev_addr),
  2598. freq);
  2599. wpas_p2p_join_scan_req(wpa_s, freq);
  2600. return;
  2601. }
  2602. }
  2603. if (join < 0)
  2604. join = 0;
  2605. wpa_s->p2p_auto_pd = 0;
  2606. wpa_s->pending_pd_use = join ? AUTO_PD_JOIN : AUTO_PD_GO_NEG;
  2607. wpa_printf(MSG_DEBUG, "P2P: Auto PD with " MACSTR " join=%d",
  2608. MAC2STR(wpa_s->pending_join_dev_addr), join);
  2609. if (p2p_prov_disc_req(wpa_s->global->p2p,
  2610. wpa_s->pending_join_dev_addr,
  2611. wpa_s->pending_pd_config_methods, join,
  2612. 0) < 0) {
  2613. wpa_s->p2p_auto_pd = 0;
  2614. wpa_msg(wpa_s, MSG_INFO, P2P_EVENT_PROV_DISC_FAILURE
  2615. " p2p_dev_addr=" MACSTR " status=N/A",
  2616. MAC2STR(wpa_s->pending_join_dev_addr));
  2617. }
  2618. return;
  2619. }
  2620. if (wpa_s->p2p_auto_join) {
  2621. int join = wpas_p2p_peer_go(wpa_s,
  2622. wpa_s->pending_join_dev_addr);
  2623. if (join < 0) {
  2624. wpa_printf(MSG_DEBUG, "P2P: Peer was not found to be "
  2625. "running a GO -> use GO Negotiation");
  2626. wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr,
  2627. wpa_s->p2p_pin, wpa_s->p2p_wps_method,
  2628. wpa_s->p2p_persistent_group, 0, 0, 0,
  2629. wpa_s->p2p_go_intent,
  2630. wpa_s->p2p_connect_freq,
  2631. wpa_s->p2p_persistent_id,
  2632. wpa_s->p2p_pd_before_go_neg,
  2633. wpa_s->p2p_go_ht40);
  2634. return;
  2635. }
  2636. wpa_printf(MSG_DEBUG, "P2P: Peer was found running GO%s -> "
  2637. "try to join the group", join ? "" :
  2638. " in older scan");
  2639. if (!join)
  2640. wpa_s->p2p_fallback_to_go_neg = 1;
  2641. }
  2642. freq = p2p_get_oper_freq(wpa_s->global->p2p,
  2643. wpa_s->pending_join_iface_addr);
  2644. if (freq < 0 &&
  2645. p2p_get_interface_addr(wpa_s->global->p2p,
  2646. wpa_s->pending_join_dev_addr,
  2647. iface_addr) == 0 &&
  2648. os_memcmp(iface_addr, wpa_s->pending_join_dev_addr, ETH_ALEN) != 0)
  2649. {
  2650. wpa_printf(MSG_DEBUG, "P2P: Overwrite pending interface "
  2651. "address for join from " MACSTR " to " MACSTR
  2652. " based on newly discovered P2P peer entry",
  2653. MAC2STR(wpa_s->pending_join_iface_addr),
  2654. MAC2STR(iface_addr));
  2655. os_memcpy(wpa_s->pending_join_iface_addr, iface_addr,
  2656. ETH_ALEN);
  2657. freq = p2p_get_oper_freq(wpa_s->global->p2p,
  2658. wpa_s->pending_join_iface_addr);
  2659. }
  2660. if (freq >= 0) {
  2661. wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency "
  2662. "from P2P peer table: %d MHz", freq);
  2663. }
  2664. bss = wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr);
  2665. if (bss) {
  2666. freq = bss->freq;
  2667. wpa_printf(MSG_DEBUG, "P2P: Target GO operating frequency "
  2668. "from BSS table: %d MHz", freq);
  2669. }
  2670. if (freq > 0) {
  2671. u16 method;
  2672. if (wpas_check_freq_conflict(wpa_s, freq) > 0) {
  2673. wpa_msg(wpa_s->parent, MSG_INFO,
  2674. P2P_EVENT_GROUP_FORMATION_FAILURE
  2675. "reason=FREQ_CONFLICT");
  2676. return;
  2677. }
  2678. wpa_printf(MSG_DEBUG, "P2P: Send Provision Discovery Request "
  2679. "prior to joining an existing group (GO " MACSTR
  2680. " freq=%u MHz)",
  2681. MAC2STR(wpa_s->pending_join_dev_addr), freq);
  2682. wpa_s->pending_pd_before_join = 1;
  2683. switch (wpa_s->pending_join_wps_method) {
  2684. case WPS_PIN_DISPLAY:
  2685. method = WPS_CONFIG_KEYPAD;
  2686. break;
  2687. case WPS_PIN_KEYPAD:
  2688. method = WPS_CONFIG_DISPLAY;
  2689. break;
  2690. case WPS_PBC:
  2691. method = WPS_CONFIG_PUSHBUTTON;
  2692. break;
  2693. default:
  2694. method = 0;
  2695. break;
  2696. }
  2697. if ((p2p_get_provisioning_info(wpa_s->global->p2p,
  2698. wpa_s->pending_join_dev_addr) ==
  2699. method)) {
  2700. /*
  2701. * We have already performed provision discovery for
  2702. * joining the group. Proceed directly to join
  2703. * operation without duplicated provision discovery. */
  2704. wpa_printf(MSG_DEBUG, "P2P: Provision discovery "
  2705. "with " MACSTR " already done - proceed to "
  2706. "join",
  2707. MAC2STR(wpa_s->pending_join_dev_addr));
  2708. wpa_s->pending_pd_before_join = 0;
  2709. goto start;
  2710. }
  2711. if (p2p_prov_disc_req(wpa_s->global->p2p,
  2712. wpa_s->pending_join_dev_addr, method, 1,
  2713. freq) < 0) {
  2714. wpa_printf(MSG_DEBUG, "P2P: Failed to send Provision "
  2715. "Discovery Request before joining an "
  2716. "existing group");
  2717. wpa_s->pending_pd_before_join = 0;
  2718. goto start;
  2719. }
  2720. /*
  2721. * Actual join operation will be started from the Action frame
  2722. * TX status callback (if no ACK is received) or when the
  2723. * Provision Discovery Response is received. Use a short
  2724. * timeout as a backup mechanism should the Provision Discovery
  2725. * Response be lost for any reason.
  2726. */
  2727. eloop_cancel_timeout(wpas_p2p_pd_before_join_timeout, wpa_s,
  2728. NULL);
  2729. eloop_register_timeout(2, 0, wpas_p2p_pd_before_join_timeout,
  2730. wpa_s, NULL);
  2731. return;
  2732. }
  2733. wpa_printf(MSG_DEBUG, "P2P: Failed to find BSS/GO - try again later");
  2734. eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
  2735. eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
  2736. wpas_p2p_check_join_scan_limit(wpa_s);
  2737. return;
  2738. start:
  2739. /* Start join operation immediately */
  2740. wpas_p2p_join_start(wpa_s);
  2741. }
  2742. static void wpas_p2p_join_scan_req(struct wpa_supplicant *wpa_s, int freq)
  2743. {
  2744. int ret;
  2745. struct wpa_driver_scan_params params;
  2746. struct wpabuf *wps_ie, *ies;
  2747. size_t ielen;
  2748. int freqs[2] = { 0, 0 };
  2749. os_memset(&params, 0, sizeof(params));
  2750. /* P2P Wildcard SSID */
  2751. params.num_ssids = 1;
  2752. params.ssids[0].ssid = (u8 *) P2P_WILDCARD_SSID;
  2753. params.ssids[0].ssid_len = P2P_WILDCARD_SSID_LEN;
  2754. wpa_s->wps->dev.p2p = 1;
  2755. wps_ie = wps_build_probe_req_ie(DEV_PW_DEFAULT, &wpa_s->wps->dev,
  2756. wpa_s->wps->uuid, WPS_REQ_ENROLLEE, 0,
  2757. NULL);
  2758. if (wps_ie == NULL) {
  2759. wpas_p2p_scan_res_join(wpa_s, NULL);
  2760. return;
  2761. }
  2762. ielen = p2p_scan_ie_buf_len(wpa_s->global->p2p);
  2763. ies = wpabuf_alloc(wpabuf_len(wps_ie) + ielen);
  2764. if (ies == NULL) {
  2765. wpabuf_free(wps_ie);
  2766. wpas_p2p_scan_res_join(wpa_s, NULL);
  2767. return;
  2768. }
  2769. wpabuf_put_buf(ies, wps_ie);
  2770. wpabuf_free(wps_ie);
  2771. p2p_scan_ie(wpa_s->global->p2p, ies, NULL);
  2772. params.p2p_probe = 1;
  2773. params.extra_ies = wpabuf_head(ies);
  2774. params.extra_ies_len = wpabuf_len(ies);
  2775. if (freq > 0) {
  2776. freqs[0] = freq;
  2777. params.freqs = freqs;
  2778. }
  2779. /*
  2780. * Run a scan to update BSS table and start Provision Discovery once
  2781. * the new scan results become available.
  2782. */
  2783. ret = wpa_drv_scan(wpa_s, &params);
  2784. if (!ret)
  2785. wpa_s->scan_res_handler = wpas_p2p_scan_res_join;
  2786. wpabuf_free(ies);
  2787. if (ret) {
  2788. wpa_printf(MSG_DEBUG, "P2P: Failed to start scan for join - "
  2789. "try again later");
  2790. eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
  2791. eloop_register_timeout(1, 0, wpas_p2p_join_scan, wpa_s, NULL);
  2792. wpas_p2p_check_join_scan_limit(wpa_s);
  2793. }
  2794. }
  2795. static void wpas_p2p_join_scan(void *eloop_ctx, void *timeout_ctx)
  2796. {
  2797. struct wpa_supplicant *wpa_s = eloop_ctx;
  2798. wpas_p2p_join_scan_req(wpa_s, 0);
  2799. }
  2800. static int wpas_p2p_join(struct wpa_supplicant *wpa_s, const u8 *iface_addr,
  2801. const u8 *dev_addr, enum p2p_wps_method wps_method,
  2802. int auto_join)
  2803. {
  2804. wpa_printf(MSG_DEBUG, "P2P: Request to join existing group (iface "
  2805. MACSTR " dev " MACSTR ")%s",
  2806. MAC2STR(iface_addr), MAC2STR(dev_addr),
  2807. auto_join ? " (auto_join)" : "");
  2808. wpa_s->p2p_auto_pd = 0;
  2809. wpa_s->p2p_auto_join = !!auto_join;
  2810. os_memcpy(wpa_s->pending_join_iface_addr, iface_addr, ETH_ALEN);
  2811. os_memcpy(wpa_s->pending_join_dev_addr, dev_addr, ETH_ALEN);
  2812. wpa_s->pending_join_wps_method = wps_method;
  2813. /* Make sure we are not running find during connection establishment */
  2814. wpas_p2p_stop_find(wpa_s);
  2815. wpa_s->p2p_join_scan_count = 0;
  2816. wpas_p2p_join_scan(wpa_s, NULL);
  2817. return 0;
  2818. }
  2819. static int wpas_p2p_join_start(struct wpa_supplicant *wpa_s)
  2820. {
  2821. struct wpa_supplicant *group;
  2822. struct p2p_go_neg_results res;
  2823. struct wpa_bss *bss;
  2824. eloop_cancel_timeout(wpas_p2p_pd_before_join_timeout, wpa_s, NULL);
  2825. group = wpas_p2p_get_group_iface(wpa_s, 0, 0);
  2826. if (group == NULL)
  2827. return -1;
  2828. if (group != wpa_s) {
  2829. os_memcpy(group->p2p_pin, wpa_s->p2p_pin,
  2830. sizeof(group->p2p_pin));
  2831. group->p2p_wps_method = wpa_s->p2p_wps_method;
  2832. }
  2833. group->p2p_in_provisioning = 1;
  2834. group->p2p_fallback_to_go_neg = wpa_s->p2p_fallback_to_go_neg;
  2835. os_memset(&res, 0, sizeof(res));
  2836. os_memcpy(res.peer_interface_addr, wpa_s->pending_join_iface_addr,
  2837. ETH_ALEN);
  2838. res.wps_method = wpa_s->pending_join_wps_method;
  2839. bss = wpa_bss_get_bssid(wpa_s, wpa_s->pending_join_iface_addr);
  2840. if (bss) {
  2841. res.freq = bss->freq;
  2842. res.ssid_len = bss->ssid_len;
  2843. os_memcpy(res.ssid, bss->ssid, bss->ssid_len);
  2844. }
  2845. if (wpa_s->off_channel_freq || wpa_s->roc_waiting_drv_freq) {
  2846. wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel prior to "
  2847. "starting client");
  2848. wpa_drv_cancel_remain_on_channel(wpa_s);
  2849. wpa_s->off_channel_freq = 0;
  2850. wpa_s->roc_waiting_drv_freq = 0;
  2851. }
  2852. wpas_start_wps_enrollee(group, &res);
  2853. /*
  2854. * Allow a longer timeout for join-a-running-group than normal 15
  2855. * second group formation timeout since the GO may not have authorized
  2856. * our connection yet.
  2857. */
  2858. eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s, NULL);
  2859. eloop_register_timeout(60, 0, wpas_p2p_group_formation_timeout,
  2860. wpa_s, NULL);
  2861. return 0;
  2862. }
  2863. /**
  2864. * wpas_p2p_connect - Request P2P Group Formation to be started
  2865. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  2866. * @peer_addr: Address of the peer P2P Device
  2867. * @pin: PIN to use during provisioning or %NULL to indicate PBC mode
  2868. * @persistent_group: Whether to create a persistent group
  2869. * @auto_join: Whether to select join vs. GO Negotiation automatically
  2870. * @join: Whether to join an existing group (as a client) instead of starting
  2871. * Group Owner negotiation; @peer_addr is BSSID in that case
  2872. * @auth: Whether to only authorize the connection instead of doing that and
  2873. * initiating Group Owner negotiation
  2874. * @go_intent: GO Intent or -1 to use default
  2875. * @freq: Frequency for the group or 0 for auto-selection
  2876. * @persistent_id: Persistent group credentials to use for forcing GO
  2877. * parameters or -1 to generate new values (SSID/passphrase)
  2878. * @pd: Whether to send Provision Discovery prior to GO Negotiation as an
  2879. * interoperability workaround when initiating group formation
  2880. * @ht40: Start GO with 40 MHz channel width
  2881. * Returns: 0 or new PIN (if pin was %NULL) on success, -1 on unspecified
  2882. * failure, -2 on failure due to channel not currently available,
  2883. * -3 if forced channel is not supported
  2884. */
  2885. int wpas_p2p_connect(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
  2886. const char *pin, enum p2p_wps_method wps_method,
  2887. int persistent_group, int auto_join, int join, int auth,
  2888. int go_intent, int freq, int persistent_id, int pd,
  2889. int ht40)
  2890. {
  2891. int force_freq = 0, oper_freq = 0;
  2892. u8 bssid[ETH_ALEN];
  2893. int ret = 0;
  2894. enum wpa_driver_if_type iftype;
  2895. const u8 *if_addr;
  2896. struct wpa_ssid *ssid = NULL;
  2897. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  2898. return -1;
  2899. if (persistent_id >= 0) {
  2900. ssid = wpa_config_get_network(wpa_s->conf, persistent_id);
  2901. if (ssid == NULL || ssid->disabled != 2 ||
  2902. ssid->mode != WPAS_MODE_P2P_GO)
  2903. return -1;
  2904. }
  2905. if (go_intent < 0)
  2906. go_intent = wpa_s->conf->p2p_go_intent;
  2907. if (!auth)
  2908. wpa_s->p2p_long_listen = 0;
  2909. wpa_s->p2p_wps_method = wps_method;
  2910. wpa_s->p2p_persistent_group = !!persistent_group;
  2911. wpa_s->p2p_persistent_id = persistent_id;
  2912. wpa_s->p2p_go_intent = go_intent;
  2913. wpa_s->p2p_connect_freq = freq;
  2914. wpa_s->p2p_fallback_to_go_neg = 0;
  2915. wpa_s->p2p_pd_before_go_neg = !!pd;
  2916. wpa_s->p2p_go_ht40 = !!ht40;
  2917. if (pin)
  2918. os_strlcpy(wpa_s->p2p_pin, pin, sizeof(wpa_s->p2p_pin));
  2919. else if (wps_method == WPS_PIN_DISPLAY) {
  2920. ret = wps_generate_pin();
  2921. os_snprintf(wpa_s->p2p_pin, sizeof(wpa_s->p2p_pin), "%08d",
  2922. ret);
  2923. wpa_printf(MSG_DEBUG, "P2P: Randomly generated PIN: %s",
  2924. wpa_s->p2p_pin);
  2925. } else
  2926. wpa_s->p2p_pin[0] = '\0';
  2927. if (join || auto_join) {
  2928. u8 iface_addr[ETH_ALEN], dev_addr[ETH_ALEN];
  2929. if (auth) {
  2930. wpa_printf(MSG_DEBUG, "P2P: Authorize invitation to "
  2931. "connect a running group from " MACSTR,
  2932. MAC2STR(peer_addr));
  2933. os_memcpy(wpa_s->p2p_auth_invite, peer_addr, ETH_ALEN);
  2934. return ret;
  2935. }
  2936. os_memcpy(dev_addr, peer_addr, ETH_ALEN);
  2937. if (p2p_get_interface_addr(wpa_s->global->p2p, peer_addr,
  2938. iface_addr) < 0) {
  2939. os_memcpy(iface_addr, peer_addr, ETH_ALEN);
  2940. p2p_get_dev_addr(wpa_s->global->p2p, peer_addr,
  2941. dev_addr);
  2942. }
  2943. if (auto_join) {
  2944. os_get_time(&wpa_s->p2p_auto_started);
  2945. wpa_printf(MSG_DEBUG, "P2P: Auto join started at "
  2946. "%ld.%06ld",
  2947. wpa_s->p2p_auto_started.sec,
  2948. wpa_s->p2p_auto_started.usec);
  2949. }
  2950. if (wpas_p2p_join(wpa_s, iface_addr, dev_addr, wps_method,
  2951. auto_join) < 0)
  2952. return -1;
  2953. return ret;
  2954. }
  2955. if (wpa_s->current_ssid && wpa_drv_get_bssid(wpa_s, bssid) == 0 &&
  2956. wpa_s->assoc_freq)
  2957. oper_freq = wpa_s->assoc_freq;
  2958. else {
  2959. oper_freq = wpa_drv_shared_freq(wpa_s);
  2960. if (oper_freq < 0)
  2961. oper_freq = 0;
  2962. }
  2963. if (freq > 0) {
  2964. if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
  2965. wpa_printf(MSG_DEBUG, "P2P: The forced channel "
  2966. "(%u MHz) is not supported for P2P uses",
  2967. freq);
  2968. return -3;
  2969. }
  2970. if (oper_freq > 0 && freq != oper_freq &&
  2971. !(wpa_s->drv_flags &
  2972. WPA_DRIVER_FLAGS_MULTI_CHANNEL_CONCURRENT)) {
  2973. wpa_printf(MSG_DEBUG, "P2P: Cannot start P2P group "
  2974. "on %u MHz while connected on another "
  2975. "channel (%u MHz)", freq, oper_freq);
  2976. return -2;
  2977. }
  2978. wpa_printf(MSG_DEBUG, "P2P: Trying to force us to use the "
  2979. "requested channel (%u MHz)", freq);
  2980. force_freq = freq;
  2981. } else if (oper_freq > 0 &&
  2982. !p2p_supported_freq(wpa_s->global->p2p, oper_freq)) {
  2983. if (!(wpa_s->drv_flags &
  2984. WPA_DRIVER_FLAGS_MULTI_CHANNEL_CONCURRENT)) {
  2985. wpa_printf(MSG_DEBUG, "P2P: Cannot start P2P group "
  2986. "while connected on non-P2P supported "
  2987. "channel (%u MHz)", oper_freq);
  2988. return -2;
  2989. }
  2990. wpa_printf(MSG_DEBUG, "P2P: Current operating channel "
  2991. "(%u MHz) not available for P2P - try to use "
  2992. "another channel", oper_freq);
  2993. force_freq = 0;
  2994. } else if (oper_freq > 0) {
  2995. wpa_printf(MSG_DEBUG, "P2P: Trying to force us to use the "
  2996. "channel we are already using (%u MHz) on another "
  2997. "interface", oper_freq);
  2998. force_freq = oper_freq;
  2999. }
  3000. wpa_s->create_p2p_iface = wpas_p2p_create_iface(wpa_s);
  3001. if (wpa_s->create_p2p_iface) {
  3002. /* Prepare to add a new interface for the group */
  3003. iftype = WPA_IF_P2P_GROUP;
  3004. if (go_intent == 15)
  3005. iftype = WPA_IF_P2P_GO;
  3006. if (wpas_p2p_add_group_interface(wpa_s, iftype) < 0) {
  3007. wpa_printf(MSG_ERROR, "P2P: Failed to allocate a new "
  3008. "interface for the group");
  3009. return -1;
  3010. }
  3011. if_addr = wpa_s->pending_interface_addr;
  3012. } else
  3013. if_addr = wpa_s->own_addr;
  3014. if (auth) {
  3015. if (wpas_p2p_auth_go_neg(wpa_s, peer_addr, wps_method,
  3016. go_intent, if_addr,
  3017. force_freq, persistent_group, ssid) <
  3018. 0)
  3019. return -1;
  3020. return ret;
  3021. }
  3022. if (wpas_p2p_start_go_neg(wpa_s, peer_addr, wps_method,
  3023. go_intent, if_addr, force_freq,
  3024. persistent_group, ssid) < 0) {
  3025. if (wpa_s->create_p2p_iface)
  3026. wpas_p2p_remove_pending_group_interface(wpa_s);
  3027. return -1;
  3028. }
  3029. return ret;
  3030. }
  3031. /**
  3032. * wpas_p2p_remain_on_channel_cb - Indication of remain-on-channel start
  3033. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  3034. * @freq: Frequency of the channel in MHz
  3035. * @duration: Duration of the stay on the channel in milliseconds
  3036. *
  3037. * This callback is called when the driver indicates that it has started the
  3038. * requested remain-on-channel duration.
  3039. */
  3040. void wpas_p2p_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
  3041. unsigned int freq, unsigned int duration)
  3042. {
  3043. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3044. return;
  3045. if (wpa_s->off_channel_freq == wpa_s->pending_listen_freq) {
  3046. p2p_listen_cb(wpa_s->global->p2p, wpa_s->pending_listen_freq,
  3047. wpa_s->pending_listen_duration);
  3048. wpa_s->pending_listen_freq = 0;
  3049. }
  3050. }
  3051. static int wpas_p2p_listen_start(struct wpa_supplicant *wpa_s,
  3052. unsigned int timeout)
  3053. {
  3054. /* Limit maximum Listen state time based on driver limitation. */
  3055. if (timeout > wpa_s->max_remain_on_chan)
  3056. timeout = wpa_s->max_remain_on_chan;
  3057. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3058. return wpa_drv_p2p_listen(wpa_s, timeout);
  3059. return p2p_listen(wpa_s->global->p2p, timeout);
  3060. }
  3061. /**
  3062. * wpas_p2p_cancel_remain_on_channel_cb - Remain-on-channel timeout
  3063. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  3064. * @freq: Frequency of the channel in MHz
  3065. *
  3066. * This callback is called when the driver indicates that a remain-on-channel
  3067. * operation has been completed, i.e., the duration on the requested channel
  3068. * has timed out.
  3069. */
  3070. void wpas_p2p_cancel_remain_on_channel_cb(struct wpa_supplicant *wpa_s,
  3071. unsigned int freq)
  3072. {
  3073. wpa_printf(MSG_DEBUG, "P2P: Cancel remain-on-channel callback "
  3074. "(p2p_long_listen=%d ms pending_action_tx=%p)",
  3075. wpa_s->p2p_long_listen, wpa_s->pending_action_tx);
  3076. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3077. return;
  3078. if (p2p_listen_end(wpa_s->global->p2p, freq) > 0)
  3079. return; /* P2P module started a new operation */
  3080. if (wpa_s->pending_action_tx)
  3081. return;
  3082. if (wpa_s->p2p_long_listen > 0)
  3083. wpa_s->p2p_long_listen -= wpa_s->max_remain_on_chan;
  3084. if (wpa_s->p2p_long_listen > 0) {
  3085. wpa_printf(MSG_DEBUG, "P2P: Continuing long Listen state");
  3086. wpas_p2p_listen_start(wpa_s, wpa_s->p2p_long_listen);
  3087. }
  3088. }
  3089. /**
  3090. * wpas_p2p_group_remove - Remove a P2P group
  3091. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  3092. * @ifname: Network interface name of the group interface or "*" to remove all
  3093. * groups
  3094. * Returns: 0 on success, -1 on failure
  3095. *
  3096. * This function is used to remove a P2P group. This can be used to disconnect
  3097. * from a group in which the local end is a P2P Client or to end a P2P Group in
  3098. * case the local end is the Group Owner. If a virtual network interface was
  3099. * created for this group, that interface will be removed. Otherwise, only the
  3100. * configured P2P group network will be removed from the interface.
  3101. */
  3102. int wpas_p2p_group_remove(struct wpa_supplicant *wpa_s, const char *ifname)
  3103. {
  3104. struct wpa_global *global = wpa_s->global;
  3105. if (os_strcmp(ifname, "*") == 0) {
  3106. struct wpa_supplicant *prev;
  3107. wpa_s = global->ifaces;
  3108. while (wpa_s) {
  3109. prev = wpa_s;
  3110. wpa_s = wpa_s->next;
  3111. wpas_p2p_disconnect(prev);
  3112. }
  3113. return 0;
  3114. }
  3115. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  3116. if (os_strcmp(wpa_s->ifname, ifname) == 0)
  3117. break;
  3118. }
  3119. return wpas_p2p_disconnect(wpa_s);
  3120. }
  3121. static int wpas_p2p_init_go_params(struct wpa_supplicant *wpa_s,
  3122. struct p2p_go_neg_results *params,
  3123. int freq, int ht40)
  3124. {
  3125. u8 bssid[ETH_ALEN];
  3126. int res;
  3127. os_memset(params, 0, sizeof(*params));
  3128. params->role_go = 1;
  3129. params->ht40 = ht40;
  3130. if (freq) {
  3131. wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on forced "
  3132. "frequency %d MHz", freq);
  3133. params->freq = freq;
  3134. } else if (wpa_s->conf->p2p_oper_reg_class == 81 &&
  3135. wpa_s->conf->p2p_oper_channel >= 1 &&
  3136. wpa_s->conf->p2p_oper_channel <= 11) {
  3137. params->freq = 2407 + 5 * wpa_s->conf->p2p_oper_channel;
  3138. wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured "
  3139. "frequency %d MHz", params->freq);
  3140. } else if (wpa_s->conf->p2p_oper_reg_class == 115 ||
  3141. wpa_s->conf->p2p_oper_reg_class == 124) {
  3142. params->freq = 5000 + 5 * wpa_s->conf->p2p_oper_channel;
  3143. wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on configured "
  3144. "frequency %d MHz", params->freq);
  3145. } else if (wpa_s->conf->p2p_oper_channel == 0 &&
  3146. wpa_s->best_overall_freq > 0 &&
  3147. p2p_supported_freq(wpa_s->global->p2p,
  3148. wpa_s->best_overall_freq)) {
  3149. params->freq = wpa_s->best_overall_freq;
  3150. wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best overall "
  3151. "channel %d MHz", params->freq);
  3152. } else if (wpa_s->conf->p2p_oper_channel == 0 &&
  3153. wpa_s->best_24_freq > 0 &&
  3154. p2p_supported_freq(wpa_s->global->p2p,
  3155. wpa_s->best_24_freq)) {
  3156. params->freq = wpa_s->best_24_freq;
  3157. wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 2.4 GHz "
  3158. "channel %d MHz", params->freq);
  3159. } else if (wpa_s->conf->p2p_oper_channel == 0 &&
  3160. wpa_s->best_5_freq > 0 &&
  3161. p2p_supported_freq(wpa_s->global->p2p,
  3162. wpa_s->best_5_freq)) {
  3163. params->freq = wpa_s->best_5_freq;
  3164. wpa_printf(MSG_DEBUG, "P2P: Set GO freq based on best 5 GHz "
  3165. "channel %d MHz", params->freq);
  3166. } else {
  3167. int chan;
  3168. for (chan = 0; chan < 11; chan++) {
  3169. params->freq = 2412 + chan * 5;
  3170. if (!wpas_p2p_disallowed_freq(wpa_s->global,
  3171. params->freq))
  3172. break;
  3173. }
  3174. if (chan == 11) {
  3175. wpa_printf(MSG_DEBUG, "P2P: No 2.4 GHz channel "
  3176. "allowed");
  3177. return -1;
  3178. }
  3179. wpa_printf(MSG_DEBUG, "P2P: Set GO freq %d MHz (no preference "
  3180. "known)", params->freq);
  3181. }
  3182. if (wpa_s->current_ssid && wpa_drv_get_bssid(wpa_s, bssid) == 0 &&
  3183. wpa_s->assoc_freq && !freq) {
  3184. wpa_printf(MSG_DEBUG, "P2P: Force GO on the channel we are "
  3185. "already using");
  3186. params->freq = wpa_s->assoc_freq;
  3187. }
  3188. res = wpa_drv_shared_freq(wpa_s);
  3189. if (res > 0 && !freq) {
  3190. wpa_printf(MSG_DEBUG, "P2P: Force GO on the channel we are "
  3191. "already using on a shared interface");
  3192. params->freq = res;
  3193. } else if (res > 0 && freq != res &&
  3194. !(wpa_s->drv_flags &
  3195. WPA_DRIVER_FLAGS_MULTI_CHANNEL_CONCURRENT)) {
  3196. wpa_printf(MSG_DEBUG, "P2P: Cannot start P2P group on %u MHz "
  3197. "while connected on another channel (%u MHz)",
  3198. freq, res);
  3199. return -1;
  3200. }
  3201. return 0;
  3202. }
  3203. static struct wpa_supplicant *
  3204. wpas_p2p_get_group_iface(struct wpa_supplicant *wpa_s, int addr_allocated,
  3205. int go)
  3206. {
  3207. struct wpa_supplicant *group_wpa_s;
  3208. if (!wpas_p2p_create_iface(wpa_s)) {
  3209. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use same interface for group "
  3210. "operations");
  3211. return wpa_s;
  3212. }
  3213. if (wpas_p2p_add_group_interface(wpa_s, go ? WPA_IF_P2P_GO :
  3214. WPA_IF_P2P_CLIENT) < 0) {
  3215. wpa_msg(wpa_s, MSG_ERROR, "P2P: Failed to add group interface");
  3216. return NULL;
  3217. }
  3218. group_wpa_s = wpas_p2p_init_group_interface(wpa_s, go);
  3219. if (group_wpa_s == NULL) {
  3220. wpa_msg(wpa_s, MSG_ERROR, "P2P: Failed to initialize group "
  3221. "interface");
  3222. wpas_p2p_remove_pending_group_interface(wpa_s);
  3223. return NULL;
  3224. }
  3225. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use separate group interface %s",
  3226. group_wpa_s->ifname);
  3227. return group_wpa_s;
  3228. }
  3229. /**
  3230. * wpas_p2p_group_add - Add a new P2P group with local end as Group Owner
  3231. * @wpa_s: Pointer to wpa_supplicant data from wpa_supplicant_add_iface()
  3232. * @persistent_group: Whether to create a persistent group
  3233. * @freq: Frequency for the group or 0 to indicate no hardcoding
  3234. * Returns: 0 on success, -1 on failure
  3235. *
  3236. * This function creates a new P2P group with the local end as the Group Owner,
  3237. * i.e., without using Group Owner Negotiation.
  3238. */
  3239. int wpas_p2p_group_add(struct wpa_supplicant *wpa_s, int persistent_group,
  3240. int freq, int ht40)
  3241. {
  3242. struct p2p_go_neg_results params;
  3243. unsigned int r;
  3244. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3245. return -1;
  3246. /* Make sure we are not running find during connection establishment */
  3247. wpa_printf(MSG_DEBUG, "P2P: Stop any on-going P2P FIND");
  3248. wpas_p2p_stop_find(wpa_s);
  3249. if (freq == 2) {
  3250. wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 2.4 GHz "
  3251. "band");
  3252. if (wpa_s->best_24_freq > 0 &&
  3253. p2p_supported_freq(wpa_s->global->p2p,
  3254. wpa_s->best_24_freq)) {
  3255. freq = wpa_s->best_24_freq;
  3256. wpa_printf(MSG_DEBUG, "P2P: Use best 2.4 GHz band "
  3257. "channel: %d MHz", freq);
  3258. } else {
  3259. os_get_random((u8 *) &r, sizeof(r));
  3260. freq = 2412 + (r % 3) * 25;
  3261. wpa_printf(MSG_DEBUG, "P2P: Use random 2.4 GHz band "
  3262. "channel: %d MHz", freq);
  3263. }
  3264. }
  3265. if (freq == 5) {
  3266. wpa_printf(MSG_DEBUG, "P2P: Request to start GO on 5 GHz "
  3267. "band");
  3268. if (wpa_s->best_5_freq > 0 &&
  3269. p2p_supported_freq(wpa_s->global->p2p,
  3270. wpa_s->best_5_freq)) {
  3271. freq = wpa_s->best_5_freq;
  3272. wpa_printf(MSG_DEBUG, "P2P: Use best 5 GHz band "
  3273. "channel: %d MHz", freq);
  3274. } else {
  3275. os_get_random((u8 *) &r, sizeof(r));
  3276. freq = 5180 + (r % 4) * 20;
  3277. if (!p2p_supported_freq(wpa_s->global->p2p, freq)) {
  3278. wpa_printf(MSG_DEBUG, "P2P: Could not select "
  3279. "5 GHz channel for P2P group");
  3280. return -1;
  3281. }
  3282. wpa_printf(MSG_DEBUG, "P2P: Use random 5 GHz band "
  3283. "channel: %d MHz", freq);
  3284. }
  3285. }
  3286. if (freq > 0 && !p2p_supported_freq(wpa_s->global->p2p, freq)) {
  3287. wpa_printf(MSG_DEBUG, "P2P: The forced channel for GO "
  3288. "(%u MHz) is not supported for P2P uses",
  3289. freq);
  3290. return -1;
  3291. }
  3292. if (wpas_p2p_init_go_params(wpa_s, &params, freq, ht40))
  3293. return -1;
  3294. if (params.freq &&
  3295. !p2p_supported_freq(wpa_s->global->p2p, params.freq)) {
  3296. wpa_printf(MSG_DEBUG, "P2P: The selected channel for GO "
  3297. "(%u MHz) is not supported for P2P uses",
  3298. params.freq);
  3299. return -1;
  3300. }
  3301. p2p_go_params(wpa_s->global->p2p, &params);
  3302. params.persistent_group = persistent_group;
  3303. wpa_s = wpas_p2p_get_group_iface(wpa_s, 0, 1);
  3304. if (wpa_s == NULL)
  3305. return -1;
  3306. wpas_start_wps_go(wpa_s, &params, 0);
  3307. return 0;
  3308. }
  3309. static int wpas_start_p2p_client(struct wpa_supplicant *wpa_s,
  3310. struct wpa_ssid *params, int addr_allocated)
  3311. {
  3312. struct wpa_ssid *ssid;
  3313. wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 0);
  3314. if (wpa_s == NULL)
  3315. return -1;
  3316. wpa_supplicant_ap_deinit(wpa_s);
  3317. ssid = wpa_config_add_network(wpa_s->conf);
  3318. if (ssid == NULL)
  3319. return -1;
  3320. wpa_config_set_network_defaults(ssid);
  3321. ssid->temporary = 1;
  3322. ssid->proto = WPA_PROTO_RSN;
  3323. ssid->pairwise_cipher = WPA_CIPHER_CCMP;
  3324. ssid->group_cipher = WPA_CIPHER_CCMP;
  3325. ssid->key_mgmt = WPA_KEY_MGMT_PSK;
  3326. ssid->ssid = os_malloc(params->ssid_len);
  3327. if (ssid->ssid == NULL) {
  3328. wpa_config_remove_network(wpa_s->conf, ssid->id);
  3329. return -1;
  3330. }
  3331. os_memcpy(ssid->ssid, params->ssid, params->ssid_len);
  3332. ssid->ssid_len = params->ssid_len;
  3333. ssid->p2p_group = 1;
  3334. ssid->export_keys = 1;
  3335. if (params->psk_set) {
  3336. os_memcpy(ssid->psk, params->psk, 32);
  3337. ssid->psk_set = 1;
  3338. }
  3339. if (params->passphrase)
  3340. ssid->passphrase = os_strdup(params->passphrase);
  3341. wpa_supplicant_select_network(wpa_s, ssid);
  3342. wpa_s->show_group_started = 1;
  3343. return 0;
  3344. }
  3345. int wpas_p2p_group_add_persistent(struct wpa_supplicant *wpa_s,
  3346. struct wpa_ssid *ssid, int addr_allocated,
  3347. int freq, int ht40)
  3348. {
  3349. struct p2p_go_neg_results params;
  3350. int go = 0;
  3351. if (ssid->disabled != 2 || ssid->ssid == NULL)
  3352. return -1;
  3353. if (wpas_get_p2p_group(wpa_s, ssid->ssid, ssid->ssid_len, &go) &&
  3354. go == (ssid->mode == WPAS_MODE_P2P_GO)) {
  3355. wpa_printf(MSG_DEBUG, "P2P: Requested persistent group is "
  3356. "already running");
  3357. return 0;
  3358. }
  3359. /* Make sure we are not running find during connection establishment */
  3360. wpas_p2p_stop_find(wpa_s);
  3361. wpa_s->p2p_fallback_to_go_neg = 0;
  3362. if (ssid->mode == WPAS_MODE_INFRA)
  3363. return wpas_start_p2p_client(wpa_s, ssid, addr_allocated);
  3364. if (ssid->mode != WPAS_MODE_P2P_GO)
  3365. return -1;
  3366. if (wpas_p2p_init_go_params(wpa_s, &params, freq, ht40))
  3367. return -1;
  3368. params.role_go = 1;
  3369. if (ssid->passphrase == NULL ||
  3370. os_strlen(ssid->passphrase) >= sizeof(params.passphrase)) {
  3371. wpa_printf(MSG_DEBUG, "P2P: Invalid passphrase in persistent "
  3372. "group");
  3373. return -1;
  3374. }
  3375. os_strlcpy(params.passphrase, ssid->passphrase,
  3376. sizeof(params.passphrase));
  3377. os_memcpy(params.ssid, ssid->ssid, ssid->ssid_len);
  3378. params.ssid_len = ssid->ssid_len;
  3379. params.persistent_group = 1;
  3380. wpa_s = wpas_p2p_get_group_iface(wpa_s, addr_allocated, 1);
  3381. if (wpa_s == NULL)
  3382. return -1;
  3383. wpas_start_wps_go(wpa_s, &params, 0);
  3384. return 0;
  3385. }
  3386. static void wpas_p2p_ie_update(void *ctx, struct wpabuf *beacon_ies,
  3387. struct wpabuf *proberesp_ies)
  3388. {
  3389. struct wpa_supplicant *wpa_s = ctx;
  3390. if (wpa_s->ap_iface) {
  3391. struct hostapd_data *hapd = wpa_s->ap_iface->bss[0];
  3392. if (!(hapd->conf->p2p & P2P_GROUP_OWNER)) {
  3393. wpabuf_free(beacon_ies);
  3394. wpabuf_free(proberesp_ies);
  3395. return;
  3396. }
  3397. if (beacon_ies) {
  3398. wpabuf_free(hapd->p2p_beacon_ie);
  3399. hapd->p2p_beacon_ie = beacon_ies;
  3400. }
  3401. wpabuf_free(hapd->p2p_probe_resp_ie);
  3402. hapd->p2p_probe_resp_ie = proberesp_ies;
  3403. } else {
  3404. wpabuf_free(beacon_ies);
  3405. wpabuf_free(proberesp_ies);
  3406. }
  3407. wpa_supplicant_ap_update_beacon(wpa_s);
  3408. }
  3409. static void wpas_p2p_idle_update(void *ctx, int idle)
  3410. {
  3411. struct wpa_supplicant *wpa_s = ctx;
  3412. if (!wpa_s->ap_iface)
  3413. return;
  3414. wpa_printf(MSG_DEBUG, "P2P: GO - group %sidle", idle ? "" : "not ");
  3415. if (idle)
  3416. wpas_p2p_set_group_idle_timeout(wpa_s);
  3417. else
  3418. eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL);
  3419. }
  3420. struct p2p_group * wpas_p2p_group_init(struct wpa_supplicant *wpa_s,
  3421. struct wpa_ssid *ssid)
  3422. {
  3423. struct p2p_group *group;
  3424. struct p2p_group_config *cfg;
  3425. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3426. return NULL;
  3427. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3428. return NULL;
  3429. cfg = os_zalloc(sizeof(*cfg));
  3430. if (cfg == NULL)
  3431. return NULL;
  3432. if (ssid->p2p_persistent_group && wpa_s->conf->persistent_reconnect)
  3433. cfg->persistent_group = 2;
  3434. else if (ssid->p2p_persistent_group)
  3435. cfg->persistent_group = 1;
  3436. os_memcpy(cfg->interface_addr, wpa_s->own_addr, ETH_ALEN);
  3437. if (wpa_s->max_stations &&
  3438. wpa_s->max_stations < wpa_s->conf->max_num_sta)
  3439. cfg->max_clients = wpa_s->max_stations;
  3440. else
  3441. cfg->max_clients = wpa_s->conf->max_num_sta;
  3442. os_memcpy(cfg->ssid, ssid->ssid, ssid->ssid_len);
  3443. cfg->ssid_len = ssid->ssid_len;
  3444. cfg->cb_ctx = wpa_s;
  3445. cfg->ie_update = wpas_p2p_ie_update;
  3446. cfg->idle_update = wpas_p2p_idle_update;
  3447. group = p2p_group_init(wpa_s->global->p2p, cfg);
  3448. if (group == NULL)
  3449. os_free(cfg);
  3450. if (ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION)
  3451. p2p_group_notif_formation_done(group);
  3452. wpa_s->p2p_group = group;
  3453. return group;
  3454. }
  3455. void wpas_p2p_wps_success(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
  3456. int registrar)
  3457. {
  3458. struct wpa_ssid *ssid = wpa_s->current_ssid;
  3459. if (!wpa_s->p2p_in_provisioning) {
  3460. wpa_printf(MSG_DEBUG, "P2P: Ignore WPS success event - P2P "
  3461. "provisioning not in progress");
  3462. return;
  3463. }
  3464. if (ssid && ssid->mode == WPAS_MODE_INFRA) {
  3465. u8 go_dev_addr[ETH_ALEN];
  3466. os_memcpy(go_dev_addr, wpa_s->bssid, ETH_ALEN);
  3467. wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
  3468. ssid->ssid_len);
  3469. /* Clear any stored provisioning info */
  3470. p2p_clear_provisioning_info(wpa_s->global->p2p, go_dev_addr);
  3471. }
  3472. eloop_cancel_timeout(wpas_p2p_group_formation_timeout, wpa_s->parent,
  3473. NULL);
  3474. if (ssid && ssid->mode == WPAS_MODE_INFRA) {
  3475. /*
  3476. * Use a separate timeout for initial data connection to
  3477. * complete to allow the group to be removed automatically if
  3478. * something goes wrong in this step before the P2P group idle
  3479. * timeout mechanism is taken into use.
  3480. */
  3481. eloop_register_timeout(P2P_MAX_INITIAL_CONN_WAIT, 0,
  3482. wpas_p2p_group_formation_timeout,
  3483. wpa_s->parent, NULL);
  3484. }
  3485. if (wpa_s->global->p2p)
  3486. p2p_wps_success_cb(wpa_s->global->p2p, peer_addr);
  3487. else if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3488. wpa_drv_wps_success_cb(wpa_s, peer_addr);
  3489. wpas_group_formation_completed(wpa_s, 1);
  3490. }
  3491. void wpas_p2p_wps_failed(struct wpa_supplicant *wpa_s,
  3492. struct wps_event_fail *fail)
  3493. {
  3494. if (!wpa_s->p2p_in_provisioning) {
  3495. wpa_printf(MSG_DEBUG, "P2P: Ignore WPS fail event - P2P "
  3496. "provisioning not in progress");
  3497. return;
  3498. }
  3499. if (wpa_s->go_params) {
  3500. p2p_clear_provisioning_info(
  3501. wpa_s->global->p2p,
  3502. wpa_s->go_params->peer_device_addr);
  3503. }
  3504. wpas_notify_p2p_wps_failed(wpa_s, fail);
  3505. }
  3506. int wpas_p2p_prov_disc(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
  3507. const char *config_method,
  3508. enum wpas_p2p_prov_disc_use use)
  3509. {
  3510. u16 config_methods;
  3511. wpa_s->p2p_fallback_to_go_neg = 0;
  3512. wpa_s->pending_pd_use = NORMAL_PD;
  3513. if (os_strncmp(config_method, "display", 7) == 0)
  3514. config_methods = WPS_CONFIG_DISPLAY;
  3515. else if (os_strncmp(config_method, "keypad", 6) == 0)
  3516. config_methods = WPS_CONFIG_KEYPAD;
  3517. else if (os_strncmp(config_method, "pbc", 3) == 0 ||
  3518. os_strncmp(config_method, "pushbutton", 10) == 0)
  3519. config_methods = WPS_CONFIG_PUSHBUTTON;
  3520. else {
  3521. wpa_printf(MSG_DEBUG, "P2P: Unknown config method");
  3522. return -1;
  3523. }
  3524. if (use == WPAS_P2P_PD_AUTO) {
  3525. os_memcpy(wpa_s->pending_join_dev_addr, peer_addr, ETH_ALEN);
  3526. wpa_s->pending_pd_config_methods = config_methods;
  3527. wpa_s->p2p_auto_pd = 1;
  3528. wpa_s->p2p_auto_join = 0;
  3529. wpa_s->pending_pd_before_join = 0;
  3530. wpa_s->auto_pd_scan_retry = 0;
  3531. wpas_p2p_stop_find(wpa_s);
  3532. wpa_s->p2p_join_scan_count = 0;
  3533. os_get_time(&wpa_s->p2p_auto_started);
  3534. wpa_printf(MSG_DEBUG, "P2P: Auto PD started at %ld.%06ld",
  3535. wpa_s->p2p_auto_started.sec,
  3536. wpa_s->p2p_auto_started.usec);
  3537. wpas_p2p_join_scan(wpa_s, NULL);
  3538. return 0;
  3539. }
  3540. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
  3541. return wpa_drv_p2p_prov_disc_req(wpa_s, peer_addr,
  3542. config_methods,
  3543. use == WPAS_P2P_PD_FOR_JOIN);
  3544. }
  3545. if (wpa_s->global->p2p == NULL || wpa_s->global->p2p_disabled)
  3546. return -1;
  3547. return p2p_prov_disc_req(wpa_s->global->p2p, peer_addr,
  3548. config_methods, use == WPAS_P2P_PD_FOR_JOIN,
  3549. 0);
  3550. }
  3551. int wpas_p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf,
  3552. char *end)
  3553. {
  3554. return p2p_scan_result_text(ies, ies_len, buf, end);
  3555. }
  3556. static void wpas_p2p_clear_pending_action_tx(struct wpa_supplicant *wpa_s)
  3557. {
  3558. if (!wpa_s->pending_action_tx)
  3559. return;
  3560. wpa_printf(MSG_DEBUG, "P2P: Drop pending Action TX due to new "
  3561. "operation request");
  3562. wpabuf_free(wpa_s->pending_action_tx);
  3563. wpa_s->pending_action_tx = NULL;
  3564. }
  3565. int wpas_p2p_find(struct wpa_supplicant *wpa_s, unsigned int timeout,
  3566. enum p2p_discovery_type type,
  3567. unsigned int num_req_dev_types, const u8 *req_dev_types,
  3568. const u8 *dev_id, unsigned int search_delay)
  3569. {
  3570. wpas_p2p_clear_pending_action_tx(wpa_s);
  3571. wpa_s->p2p_long_listen = 0;
  3572. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3573. return wpa_drv_p2p_find(wpa_s, timeout, type);
  3574. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL ||
  3575. wpa_s->p2p_in_provisioning)
  3576. return -1;
  3577. wpa_supplicant_cancel_sched_scan(wpa_s);
  3578. return p2p_find(wpa_s->global->p2p, timeout, type,
  3579. num_req_dev_types, req_dev_types, dev_id,
  3580. search_delay);
  3581. }
  3582. void wpas_p2p_stop_find(struct wpa_supplicant *wpa_s)
  3583. {
  3584. wpas_p2p_clear_pending_action_tx(wpa_s);
  3585. wpa_s->p2p_long_listen = 0;
  3586. eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
  3587. eloop_cancel_timeout(wpas_p2p_join_scan, wpa_s, NULL);
  3588. wpa_s->global->p2p_cb_on_scan_complete = 0;
  3589. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT) {
  3590. wpa_drv_p2p_stop_find(wpa_s);
  3591. return;
  3592. }
  3593. if (wpa_s->global->p2p)
  3594. p2p_stop_find(wpa_s->global->p2p);
  3595. wpas_p2p_remove_pending_group_interface(wpa_s);
  3596. }
  3597. static void wpas_p2p_long_listen_timeout(void *eloop_ctx, void *timeout_ctx)
  3598. {
  3599. struct wpa_supplicant *wpa_s = eloop_ctx;
  3600. wpa_s->p2p_long_listen = 0;
  3601. }
  3602. int wpas_p2p_listen(struct wpa_supplicant *wpa_s, unsigned int timeout)
  3603. {
  3604. int res;
  3605. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3606. return -1;
  3607. wpa_supplicant_cancel_sched_scan(wpa_s);
  3608. wpas_p2p_clear_pending_action_tx(wpa_s);
  3609. if (timeout == 0) {
  3610. /*
  3611. * This is a request for unlimited Listen state. However, at
  3612. * least for now, this is mapped to a Listen state for one
  3613. * hour.
  3614. */
  3615. timeout = 3600;
  3616. }
  3617. eloop_cancel_timeout(wpas_p2p_long_listen_timeout, wpa_s, NULL);
  3618. wpa_s->p2p_long_listen = 0;
  3619. /*
  3620. * Stop previous find/listen operation to avoid trying to request a new
  3621. * remain-on-channel operation while the driver is still running the
  3622. * previous one.
  3623. */
  3624. if (wpa_s->global->p2p)
  3625. p2p_stop_find(wpa_s->global->p2p);
  3626. res = wpas_p2p_listen_start(wpa_s, timeout * 1000);
  3627. if (res == 0 && timeout * 1000 > wpa_s->max_remain_on_chan) {
  3628. wpa_s->p2p_long_listen = timeout * 1000;
  3629. eloop_register_timeout(timeout, 0,
  3630. wpas_p2p_long_listen_timeout,
  3631. wpa_s, NULL);
  3632. }
  3633. return res;
  3634. }
  3635. int wpas_p2p_assoc_req_ie(struct wpa_supplicant *wpa_s, struct wpa_bss *bss,
  3636. u8 *buf, size_t len, int p2p_group)
  3637. {
  3638. struct wpabuf *p2p_ie;
  3639. int ret;
  3640. if (wpa_s->global->p2p_disabled)
  3641. return -1;
  3642. if (wpa_s->global->p2p == NULL)
  3643. return -1;
  3644. if (bss == NULL)
  3645. return -1;
  3646. p2p_ie = wpa_bss_get_vendor_ie_multi(bss, P2P_IE_VENDOR_TYPE);
  3647. ret = p2p_assoc_req_ie(wpa_s->global->p2p, bss->bssid, buf, len,
  3648. p2p_group, p2p_ie);
  3649. wpabuf_free(p2p_ie);
  3650. return ret;
  3651. }
  3652. int wpas_p2p_probe_req_rx(struct wpa_supplicant *wpa_s, const u8 *addr,
  3653. const u8 *dst, const u8 *bssid,
  3654. const u8 *ie, size_t ie_len, int ssi_signal)
  3655. {
  3656. if (wpa_s->global->p2p_disabled)
  3657. return 0;
  3658. if (wpa_s->global->p2p == NULL)
  3659. return 0;
  3660. switch (p2p_probe_req_rx(wpa_s->global->p2p, addr, dst, bssid,
  3661. ie, ie_len)) {
  3662. case P2P_PREQ_NOT_P2P:
  3663. wpas_notify_preq(wpa_s, addr, dst, bssid, ie, ie_len,
  3664. ssi_signal);
  3665. /* fall through */
  3666. case P2P_PREQ_MALFORMED:
  3667. case P2P_PREQ_NOT_LISTEN:
  3668. case P2P_PREQ_NOT_PROCESSED:
  3669. default: /* make gcc happy */
  3670. return 0;
  3671. case P2P_PREQ_PROCESSED:
  3672. return 1;
  3673. }
  3674. }
  3675. void wpas_p2p_rx_action(struct wpa_supplicant *wpa_s, const u8 *da,
  3676. const u8 *sa, const u8 *bssid,
  3677. u8 category, const u8 *data, size_t len, int freq)
  3678. {
  3679. if (wpa_s->global->p2p_disabled)
  3680. return;
  3681. if (wpa_s->global->p2p == NULL)
  3682. return;
  3683. p2p_rx_action(wpa_s->global->p2p, da, sa, bssid, category, data, len,
  3684. freq);
  3685. }
  3686. void wpas_p2p_scan_ie(struct wpa_supplicant *wpa_s, struct wpabuf *ies)
  3687. {
  3688. if (wpa_s->global->p2p_disabled)
  3689. return;
  3690. if (wpa_s->global->p2p == NULL)
  3691. return;
  3692. p2p_scan_ie(wpa_s->global->p2p, ies, NULL);
  3693. }
  3694. void wpas_p2p_group_deinit(struct wpa_supplicant *wpa_s)
  3695. {
  3696. p2p_group_deinit(wpa_s->p2p_group);
  3697. wpa_s->p2p_group = NULL;
  3698. wpa_s->ap_configured_cb = NULL;
  3699. wpa_s->ap_configured_cb_ctx = NULL;
  3700. wpa_s->ap_configured_cb_data = NULL;
  3701. wpa_s->connect_without_scan = NULL;
  3702. }
  3703. int wpas_p2p_reject(struct wpa_supplicant *wpa_s, const u8 *addr)
  3704. {
  3705. wpa_s->p2p_long_listen = 0;
  3706. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3707. return wpa_drv_p2p_reject(wpa_s, addr);
  3708. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3709. return -1;
  3710. return p2p_reject(wpa_s->global->p2p, addr);
  3711. }
  3712. /* Invite to reinvoke a persistent group */
  3713. int wpas_p2p_invite(struct wpa_supplicant *wpa_s, const u8 *peer_addr,
  3714. struct wpa_ssid *ssid, const u8 *go_dev_addr, int freq,
  3715. int ht40)
  3716. {
  3717. enum p2p_invite_role role;
  3718. u8 *bssid = NULL;
  3719. wpa_s->p2p_persistent_go_freq = freq;
  3720. wpa_s->p2p_go_ht40 = !!ht40;
  3721. if (ssid->mode == WPAS_MODE_P2P_GO) {
  3722. role = P2P_INVITE_ROLE_GO;
  3723. if (peer_addr == NULL) {
  3724. wpa_printf(MSG_DEBUG, "P2P: Missing peer "
  3725. "address in invitation command");
  3726. return -1;
  3727. }
  3728. if (wpas_p2p_create_iface(wpa_s)) {
  3729. if (wpas_p2p_add_group_interface(wpa_s,
  3730. WPA_IF_P2P_GO) < 0) {
  3731. wpa_printf(MSG_ERROR, "P2P: Failed to "
  3732. "allocate a new interface for the "
  3733. "group");
  3734. return -1;
  3735. }
  3736. bssid = wpa_s->pending_interface_addr;
  3737. } else
  3738. bssid = wpa_s->own_addr;
  3739. } else {
  3740. role = P2P_INVITE_ROLE_CLIENT;
  3741. peer_addr = ssid->bssid;
  3742. }
  3743. wpa_s->pending_invite_ssid_id = ssid->id;
  3744. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3745. return wpa_drv_p2p_invite(wpa_s, peer_addr, role, bssid,
  3746. ssid->ssid, ssid->ssid_len,
  3747. go_dev_addr, 1);
  3748. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3749. return -1;
  3750. return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
  3751. ssid->ssid, ssid->ssid_len, freq, go_dev_addr, 1);
  3752. }
  3753. /* Invite to join an active group */
  3754. int wpas_p2p_invite_group(struct wpa_supplicant *wpa_s, const char *ifname,
  3755. const u8 *peer_addr, const u8 *go_dev_addr)
  3756. {
  3757. struct wpa_global *global = wpa_s->global;
  3758. enum p2p_invite_role role;
  3759. u8 *bssid = NULL;
  3760. struct wpa_ssid *ssid;
  3761. int persistent;
  3762. wpa_s->p2p_persistent_go_freq = 0;
  3763. wpa_s->p2p_go_ht40 = 0;
  3764. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  3765. if (os_strcmp(wpa_s->ifname, ifname) == 0)
  3766. break;
  3767. }
  3768. if (wpa_s == NULL) {
  3769. wpa_printf(MSG_DEBUG, "P2P: Interface '%s' not found", ifname);
  3770. return -1;
  3771. }
  3772. ssid = wpa_s->current_ssid;
  3773. if (ssid == NULL) {
  3774. wpa_printf(MSG_DEBUG, "P2P: No current SSID to use for "
  3775. "invitation");
  3776. return -1;
  3777. }
  3778. persistent = ssid->p2p_persistent_group &&
  3779. wpas_p2p_get_persistent(wpa_s->parent, peer_addr,
  3780. ssid->ssid, ssid->ssid_len);
  3781. if (ssid->mode == WPAS_MODE_P2P_GO) {
  3782. role = P2P_INVITE_ROLE_ACTIVE_GO;
  3783. bssid = wpa_s->own_addr;
  3784. if (go_dev_addr == NULL)
  3785. go_dev_addr = wpa_s->global->p2p_dev_addr;
  3786. } else {
  3787. role = P2P_INVITE_ROLE_CLIENT;
  3788. if (wpa_s->wpa_state < WPA_ASSOCIATED) {
  3789. wpa_printf(MSG_DEBUG, "P2P: Not associated - cannot "
  3790. "invite to current group");
  3791. return -1;
  3792. }
  3793. bssid = wpa_s->bssid;
  3794. if (go_dev_addr == NULL &&
  3795. !is_zero_ether_addr(wpa_s->go_dev_addr))
  3796. go_dev_addr = wpa_s->go_dev_addr;
  3797. }
  3798. wpa_s->parent->pending_invite_ssid_id = -1;
  3799. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3800. return wpa_drv_p2p_invite(wpa_s, peer_addr, role, bssid,
  3801. ssid->ssid, ssid->ssid_len,
  3802. go_dev_addr, persistent);
  3803. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3804. return -1;
  3805. return p2p_invite(wpa_s->global->p2p, peer_addr, role, bssid,
  3806. ssid->ssid, ssid->ssid_len, wpa_s->assoc_freq,
  3807. go_dev_addr, persistent);
  3808. }
  3809. void wpas_p2p_completed(struct wpa_supplicant *wpa_s)
  3810. {
  3811. struct wpa_ssid *ssid = wpa_s->current_ssid;
  3812. const char *ssid_txt;
  3813. u8 go_dev_addr[ETH_ALEN];
  3814. int network_id = -1;
  3815. int persistent;
  3816. int freq;
  3817. if (ssid == NULL || ssid->mode != WPAS_MODE_P2P_GROUP_FORMATION) {
  3818. eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
  3819. wpa_s->parent, NULL);
  3820. }
  3821. if (!wpa_s->show_group_started || !ssid)
  3822. goto done;
  3823. wpa_s->show_group_started = 0;
  3824. ssid_txt = wpa_ssid_txt(ssid->ssid, ssid->ssid_len);
  3825. os_memset(go_dev_addr, 0, ETH_ALEN);
  3826. if (ssid->bssid_set)
  3827. os_memcpy(go_dev_addr, ssid->bssid, ETH_ALEN);
  3828. persistent = wpas_p2p_persistent_group(wpa_s, go_dev_addr, ssid->ssid,
  3829. ssid->ssid_len);
  3830. os_memcpy(wpa_s->go_dev_addr, go_dev_addr, ETH_ALEN);
  3831. if (wpa_s->global->p2p_group_formation == wpa_s)
  3832. wpa_s->global->p2p_group_formation = NULL;
  3833. freq = wpa_s->current_bss ? wpa_s->current_bss->freq :
  3834. (int) wpa_s->assoc_freq;
  3835. if (ssid->passphrase == NULL && ssid->psk_set) {
  3836. char psk[65];
  3837. wpa_snprintf_hex(psk, sizeof(psk), ssid->psk, 32);
  3838. wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
  3839. "%s client ssid=\"%s\" freq=%d psk=%s go_dev_addr="
  3840. MACSTR "%s",
  3841. wpa_s->ifname, ssid_txt, freq, psk,
  3842. MAC2STR(go_dev_addr),
  3843. persistent ? " [PERSISTENT]" : "");
  3844. } else {
  3845. wpa_msg(wpa_s->parent, MSG_INFO, P2P_EVENT_GROUP_STARTED
  3846. "%s client ssid=\"%s\" freq=%d passphrase=\"%s\" "
  3847. "go_dev_addr=" MACSTR "%s",
  3848. wpa_s->ifname, ssid_txt, freq,
  3849. ssid->passphrase ? ssid->passphrase : "",
  3850. MAC2STR(go_dev_addr),
  3851. persistent ? " [PERSISTENT]" : "");
  3852. }
  3853. if (persistent)
  3854. network_id = wpas_p2p_store_persistent_group(wpa_s->parent,
  3855. ssid, go_dev_addr);
  3856. if (network_id < 0)
  3857. network_id = ssid->id;
  3858. wpas_notify_p2p_group_started(wpa_s, ssid, network_id, 1);
  3859. done:
  3860. if (wpa_s->global->p2p_cb_on_scan_complete && !wpa_s->global->p2p_disabled &&
  3861. wpa_s->global->p2p != NULL) {
  3862. wpa_s->global->p2p_cb_on_scan_complete = 0;
  3863. if (p2p_other_scan_completed(wpa_s->global->p2p) == 1) {
  3864. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Pending P2P operation "
  3865. "continued after successful connection");
  3866. p2p_increase_search_delay(
  3867. wpa_s->global->p2p,
  3868. wpas_p2p_search_delay(wpa_s));
  3869. }
  3870. }
  3871. }
  3872. int wpas_p2p_presence_req(struct wpa_supplicant *wpa_s, u32 duration1,
  3873. u32 interval1, u32 duration2, u32 interval2)
  3874. {
  3875. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3876. return -1;
  3877. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3878. return -1;
  3879. if (wpa_s->wpa_state < WPA_ASSOCIATED ||
  3880. wpa_s->current_ssid == NULL ||
  3881. wpa_s->current_ssid->mode != WPAS_MODE_INFRA)
  3882. return -1;
  3883. return p2p_presence_req(wpa_s->global->p2p, wpa_s->bssid,
  3884. wpa_s->own_addr, wpa_s->assoc_freq,
  3885. duration1, interval1, duration2, interval2);
  3886. }
  3887. int wpas_p2p_ext_listen(struct wpa_supplicant *wpa_s, unsigned int period,
  3888. unsigned int interval)
  3889. {
  3890. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3891. return -1;
  3892. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3893. return -1;
  3894. return p2p_ext_listen(wpa_s->global->p2p, period, interval);
  3895. }
  3896. static int wpas_p2p_is_client(struct wpa_supplicant *wpa_s)
  3897. {
  3898. return wpa_s->current_ssid != NULL &&
  3899. wpa_s->current_ssid->p2p_group &&
  3900. wpa_s->current_ssid->mode == WPAS_MODE_INFRA;
  3901. }
  3902. static void wpas_p2p_group_idle_timeout(void *eloop_ctx, void *timeout_ctx)
  3903. {
  3904. struct wpa_supplicant *wpa_s = eloop_ctx;
  3905. if (wpa_s->conf->p2p_group_idle == 0 && !wpas_p2p_is_client(wpa_s)) {
  3906. wpa_printf(MSG_DEBUG, "P2P: Ignore group idle timeout - "
  3907. "disabled");
  3908. return;
  3909. }
  3910. wpa_printf(MSG_DEBUG, "P2P: Group idle timeout reached - terminate "
  3911. "group");
  3912. wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_IDLE_TIMEOUT);
  3913. }
  3914. static void wpas_p2p_set_group_idle_timeout(struct wpa_supplicant *wpa_s)
  3915. {
  3916. int timeout;
  3917. if (eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
  3918. wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
  3919. if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
  3920. return;
  3921. timeout = wpa_s->conf->p2p_group_idle;
  3922. if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA &&
  3923. (timeout == 0 || timeout > P2P_MAX_CLIENT_IDLE))
  3924. timeout = P2P_MAX_CLIENT_IDLE;
  3925. if (timeout == 0)
  3926. return;
  3927. if (timeout < 0) {
  3928. if (wpa_s->current_ssid->mode == WPAS_MODE_INFRA)
  3929. timeout = 0; /* special client mode no-timeout */
  3930. else
  3931. return;
  3932. }
  3933. if (wpa_s->p2p_in_provisioning) {
  3934. /*
  3935. * Use the normal group formation timeout during the
  3936. * provisioning phase to avoid terminating this process too
  3937. * early due to group idle timeout.
  3938. */
  3939. wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout "
  3940. "during provisioning");
  3941. return;
  3942. }
  3943. if (wpa_s->show_group_started) {
  3944. /*
  3945. * Use the normal group formation timeout between the end of
  3946. * the provisioning phase and completion of 4-way handshake to
  3947. * avoid terminating this process too early due to group idle
  3948. * timeout.
  3949. */
  3950. wpa_printf(MSG_DEBUG, "P2P: Do not use P2P group idle timeout "
  3951. "while waiting for initial 4-way handshake to "
  3952. "complete");
  3953. return;
  3954. }
  3955. wpa_printf(MSG_DEBUG, "P2P: Set P2P group idle timeout to %u seconds",
  3956. timeout);
  3957. eloop_register_timeout(timeout, 0, wpas_p2p_group_idle_timeout,
  3958. wpa_s, NULL);
  3959. }
  3960. /* Returns 1 if the interface was removed */
  3961. int wpas_p2p_deauth_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
  3962. u16 reason_code, const u8 *ie, size_t ie_len,
  3963. int locally_generated)
  3964. {
  3965. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3966. return 0;
  3967. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3968. return 0;
  3969. if (!locally_generated)
  3970. p2p_deauth_notif(wpa_s->global->p2p, bssid, reason_code, ie,
  3971. ie_len);
  3972. if (reason_code == WLAN_REASON_DEAUTH_LEAVING && !locally_generated &&
  3973. wpa_s->current_ssid &&
  3974. wpa_s->current_ssid->p2p_group &&
  3975. wpa_s->current_ssid->mode == WPAS_MODE_INFRA) {
  3976. wpa_printf(MSG_DEBUG, "P2P: GO indicated that the P2P Group "
  3977. "session is ending");
  3978. if (wpas_p2p_group_delete(wpa_s,
  3979. P2P_GROUP_REMOVAL_GO_ENDING_SESSION)
  3980. > 0)
  3981. return 1;
  3982. }
  3983. return 0;
  3984. }
  3985. void wpas_p2p_disassoc_notif(struct wpa_supplicant *wpa_s, const u8 *bssid,
  3986. u16 reason_code, const u8 *ie, size_t ie_len,
  3987. int locally_generated)
  3988. {
  3989. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  3990. return;
  3991. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  3992. return;
  3993. if (!locally_generated)
  3994. p2p_disassoc_notif(wpa_s->global->p2p, bssid, reason_code, ie,
  3995. ie_len);
  3996. }
  3997. void wpas_p2p_update_config(struct wpa_supplicant *wpa_s)
  3998. {
  3999. struct p2p_data *p2p = wpa_s->global->p2p;
  4000. if (p2p == NULL)
  4001. return;
  4002. if (!(wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE))
  4003. return;
  4004. if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_NAME)
  4005. p2p_set_dev_name(p2p, wpa_s->conf->device_name);
  4006. if (wpa_s->conf->changed_parameters & CFG_CHANGED_DEVICE_TYPE)
  4007. p2p_set_pri_dev_type(p2p, wpa_s->conf->device_type);
  4008. if (wpa_s->wps &&
  4009. (wpa_s->conf->changed_parameters & CFG_CHANGED_CONFIG_METHODS))
  4010. p2p_set_config_methods(p2p, wpa_s->wps->config_methods);
  4011. if (wpa_s->wps && (wpa_s->conf->changed_parameters & CFG_CHANGED_UUID))
  4012. p2p_set_uuid(p2p, wpa_s->wps->uuid);
  4013. if (wpa_s->conf->changed_parameters & CFG_CHANGED_WPS_STRING) {
  4014. p2p_set_manufacturer(p2p, wpa_s->conf->manufacturer);
  4015. p2p_set_model_name(p2p, wpa_s->conf->model_name);
  4016. p2p_set_model_number(p2p, wpa_s->conf->model_number);
  4017. p2p_set_serial_number(p2p, wpa_s->conf->serial_number);
  4018. }
  4019. if (wpa_s->conf->changed_parameters & CFG_CHANGED_SEC_DEVICE_TYPE)
  4020. p2p_set_sec_dev_types(p2p,
  4021. (void *) wpa_s->conf->sec_device_type,
  4022. wpa_s->conf->num_sec_device_types);
  4023. if (wpa_s->conf->changed_parameters & CFG_CHANGED_VENDOR_EXTENSION) {
  4024. int i;
  4025. p2p_remove_wps_vendor_extensions(p2p);
  4026. for (i = 0; i < MAX_WPS_VENDOR_EXT; i++) {
  4027. if (wpa_s->conf->wps_vendor_ext[i] == NULL)
  4028. continue;
  4029. p2p_add_wps_vendor_extension(
  4030. p2p, wpa_s->conf->wps_vendor_ext[i]);
  4031. }
  4032. }
  4033. if ((wpa_s->conf->changed_parameters & CFG_CHANGED_COUNTRY) &&
  4034. wpa_s->conf->country[0] && wpa_s->conf->country[1]) {
  4035. char country[3];
  4036. country[0] = wpa_s->conf->country[0];
  4037. country[1] = wpa_s->conf->country[1];
  4038. country[2] = 0x04;
  4039. p2p_set_country(p2p, country);
  4040. }
  4041. if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_SSID_POSTFIX) {
  4042. p2p_set_ssid_postfix(p2p, (u8 *) wpa_s->conf->p2p_ssid_postfix,
  4043. wpa_s->conf->p2p_ssid_postfix ?
  4044. os_strlen(wpa_s->conf->p2p_ssid_postfix) :
  4045. 0);
  4046. }
  4047. if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_INTRA_BSS)
  4048. p2p_set_intra_bss_dist(p2p, wpa_s->conf->p2p_intra_bss);
  4049. if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_LISTEN_CHANNEL) {
  4050. u8 reg_class, channel;
  4051. int ret;
  4052. unsigned int r;
  4053. if (wpa_s->conf->p2p_listen_reg_class &&
  4054. wpa_s->conf->p2p_listen_channel) {
  4055. reg_class = wpa_s->conf->p2p_listen_reg_class;
  4056. channel = wpa_s->conf->p2p_listen_channel;
  4057. } else {
  4058. reg_class = 81;
  4059. /*
  4060. * Pick one of the social channels randomly as the
  4061. * listen channel.
  4062. */
  4063. os_get_random((u8 *) &r, sizeof(r));
  4064. channel = 1 + (r % 3) * 5;
  4065. }
  4066. ret = p2p_set_listen_channel(p2p, reg_class, channel);
  4067. if (ret)
  4068. wpa_printf(MSG_ERROR, "P2P: Own listen channel update "
  4069. "failed: %d", ret);
  4070. }
  4071. if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_OPER_CHANNEL) {
  4072. u8 op_reg_class, op_channel, cfg_op_channel;
  4073. int ret = 0;
  4074. unsigned int r;
  4075. if (wpa_s->conf->p2p_oper_reg_class &&
  4076. wpa_s->conf->p2p_oper_channel) {
  4077. op_reg_class = wpa_s->conf->p2p_oper_reg_class;
  4078. op_channel = wpa_s->conf->p2p_oper_channel;
  4079. cfg_op_channel = 1;
  4080. } else {
  4081. op_reg_class = 81;
  4082. /*
  4083. * Use random operation channel from (1, 6, 11)
  4084. *if no other preference is indicated.
  4085. */
  4086. os_get_random((u8 *) &r, sizeof(r));
  4087. op_channel = 1 + (r % 3) * 5;
  4088. cfg_op_channel = 0;
  4089. }
  4090. ret = p2p_set_oper_channel(p2p, op_reg_class, op_channel,
  4091. cfg_op_channel);
  4092. if (ret)
  4093. wpa_printf(MSG_ERROR, "P2P: Own oper channel update "
  4094. "failed: %d", ret);
  4095. }
  4096. if (wpa_s->conf->changed_parameters & CFG_CHANGED_P2P_PREF_CHAN) {
  4097. if (p2p_set_pref_chan(p2p, wpa_s->conf->num_p2p_pref_chan,
  4098. wpa_s->conf->p2p_pref_chan) < 0) {
  4099. wpa_printf(MSG_ERROR, "P2P: Preferred channel list "
  4100. "update failed");
  4101. }
  4102. }
  4103. }
  4104. int wpas_p2p_set_noa(struct wpa_supplicant *wpa_s, u8 count, int start,
  4105. int duration)
  4106. {
  4107. if (!wpa_s->ap_iface)
  4108. return -1;
  4109. return hostapd_p2p_set_noa(wpa_s->ap_iface->bss[0], count, start,
  4110. duration);
  4111. }
  4112. int wpas_p2p_set_cross_connect(struct wpa_supplicant *wpa_s, int enabled)
  4113. {
  4114. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  4115. return -1;
  4116. if (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT)
  4117. return -1;
  4118. wpa_s->global->cross_connection = enabled;
  4119. p2p_set_cross_connect(wpa_s->global->p2p, enabled);
  4120. if (!enabled) {
  4121. struct wpa_supplicant *iface;
  4122. for (iface = wpa_s->global->ifaces; iface; iface = iface->next)
  4123. {
  4124. if (iface->cross_connect_enabled == 0)
  4125. continue;
  4126. iface->cross_connect_enabled = 0;
  4127. iface->cross_connect_in_use = 0;
  4128. wpa_msg(iface->parent, MSG_INFO,
  4129. P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
  4130. iface->ifname, iface->cross_connect_uplink);
  4131. }
  4132. }
  4133. return 0;
  4134. }
  4135. static void wpas_p2p_enable_cross_connect(struct wpa_supplicant *uplink)
  4136. {
  4137. struct wpa_supplicant *iface;
  4138. if (!uplink->global->cross_connection)
  4139. return;
  4140. for (iface = uplink->global->ifaces; iface; iface = iface->next) {
  4141. if (!iface->cross_connect_enabled)
  4142. continue;
  4143. if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
  4144. 0)
  4145. continue;
  4146. if (iface->ap_iface == NULL)
  4147. continue;
  4148. if (iface->cross_connect_in_use)
  4149. continue;
  4150. iface->cross_connect_in_use = 1;
  4151. wpa_msg(iface->parent, MSG_INFO,
  4152. P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s",
  4153. iface->ifname, iface->cross_connect_uplink);
  4154. }
  4155. }
  4156. static void wpas_p2p_disable_cross_connect(struct wpa_supplicant *uplink)
  4157. {
  4158. struct wpa_supplicant *iface;
  4159. for (iface = uplink->global->ifaces; iface; iface = iface->next) {
  4160. if (!iface->cross_connect_enabled)
  4161. continue;
  4162. if (os_strcmp(uplink->ifname, iface->cross_connect_uplink) !=
  4163. 0)
  4164. continue;
  4165. if (!iface->cross_connect_in_use)
  4166. continue;
  4167. wpa_msg(iface->parent, MSG_INFO,
  4168. P2P_EVENT_CROSS_CONNECT_DISABLE "%s %s",
  4169. iface->ifname, iface->cross_connect_uplink);
  4170. iface->cross_connect_in_use = 0;
  4171. }
  4172. }
  4173. void wpas_p2p_notif_connected(struct wpa_supplicant *wpa_s)
  4174. {
  4175. if (wpa_s->ap_iface || wpa_s->current_ssid == NULL ||
  4176. wpa_s->current_ssid->mode != WPAS_MODE_INFRA ||
  4177. wpa_s->cross_connect_disallowed)
  4178. wpas_p2p_disable_cross_connect(wpa_s);
  4179. else
  4180. wpas_p2p_enable_cross_connect(wpa_s);
  4181. if (!wpa_s->ap_iface &&
  4182. eloop_cancel_timeout(wpas_p2p_group_idle_timeout, wpa_s, NULL) > 0)
  4183. wpa_printf(MSG_DEBUG, "P2P: Cancelled P2P group idle timeout");
  4184. }
  4185. void wpas_p2p_notif_disconnected(struct wpa_supplicant *wpa_s)
  4186. {
  4187. wpas_p2p_disable_cross_connect(wpa_s);
  4188. if (!wpa_s->ap_iface &&
  4189. !eloop_is_timeout_registered(wpas_p2p_group_idle_timeout,
  4190. wpa_s, NULL))
  4191. wpas_p2p_set_group_idle_timeout(wpa_s);
  4192. }
  4193. static void wpas_p2p_cross_connect_setup(struct wpa_supplicant *wpa_s)
  4194. {
  4195. struct wpa_supplicant *iface;
  4196. if (!wpa_s->global->cross_connection)
  4197. return;
  4198. for (iface = wpa_s->global->ifaces; iface; iface = iface->next) {
  4199. if (iface == wpa_s)
  4200. continue;
  4201. if (iface->drv_flags &
  4202. WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE)
  4203. continue;
  4204. if (iface->drv_flags & WPA_DRIVER_FLAGS_P2P_CAPABLE)
  4205. continue;
  4206. wpa_s->cross_connect_enabled = 1;
  4207. os_strlcpy(wpa_s->cross_connect_uplink, iface->ifname,
  4208. sizeof(wpa_s->cross_connect_uplink));
  4209. wpa_printf(MSG_DEBUG, "P2P: Enable cross connection from "
  4210. "%s to %s whenever uplink is available",
  4211. wpa_s->ifname, wpa_s->cross_connect_uplink);
  4212. if (iface->ap_iface || iface->current_ssid == NULL ||
  4213. iface->current_ssid->mode != WPAS_MODE_INFRA ||
  4214. iface->cross_connect_disallowed ||
  4215. iface->wpa_state != WPA_COMPLETED)
  4216. break;
  4217. wpa_s->cross_connect_in_use = 1;
  4218. wpa_msg(wpa_s->parent, MSG_INFO,
  4219. P2P_EVENT_CROSS_CONNECT_ENABLE "%s %s",
  4220. wpa_s->ifname, wpa_s->cross_connect_uplink);
  4221. break;
  4222. }
  4223. }
  4224. int wpas_p2p_notif_pbc_overlap(struct wpa_supplicant *wpa_s)
  4225. {
  4226. if (wpa_s->p2p_group_interface != P2P_GROUP_INTERFACE_CLIENT &&
  4227. !wpa_s->p2p_in_provisioning)
  4228. return 0; /* not P2P client operation */
  4229. wpa_printf(MSG_DEBUG, "P2P: Terminate connection due to WPS PBC "
  4230. "session overlap");
  4231. if (wpa_s != wpa_s->parent)
  4232. wpa_msg_ctrl(wpa_s->parent, MSG_INFO, WPS_EVENT_OVERLAP);
  4233. if (wpa_s->global->p2p)
  4234. p2p_group_formation_failed(wpa_s->global->p2p);
  4235. eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
  4236. wpa_s->parent, NULL);
  4237. wpas_group_formation_completed(wpa_s, 0);
  4238. return 1;
  4239. }
  4240. void wpas_p2p_update_channel_list(struct wpa_supplicant *wpa_s)
  4241. {
  4242. struct p2p_channels chan;
  4243. if (wpa_s->global == NULL || wpa_s->global->p2p == NULL)
  4244. return;
  4245. os_memset(&chan, 0, sizeof(chan));
  4246. if (wpas_p2p_setup_channels(wpa_s, &chan)) {
  4247. wpa_printf(MSG_ERROR, "P2P: Failed to update supported "
  4248. "channel list");
  4249. return;
  4250. }
  4251. p2p_update_channel_list(wpa_s->global->p2p, &chan);
  4252. }
  4253. int wpas_p2p_cancel(struct wpa_supplicant *wpa_s)
  4254. {
  4255. struct wpa_global *global = wpa_s->global;
  4256. int found = 0;
  4257. const u8 *peer;
  4258. if (global->p2p == NULL)
  4259. return -1;
  4260. wpa_printf(MSG_DEBUG, "P2P: Request to cancel group formation");
  4261. if (wpa_s->pending_interface_name[0] &&
  4262. !is_zero_ether_addr(wpa_s->pending_interface_addr))
  4263. found = 1;
  4264. peer = p2p_get_go_neg_peer(global->p2p);
  4265. if (peer) {
  4266. wpa_printf(MSG_DEBUG, "P2P: Unauthorize pending GO Neg peer "
  4267. MACSTR, MAC2STR(peer));
  4268. p2p_unauthorize(global->p2p, peer);
  4269. found = 1;
  4270. }
  4271. wpas_p2p_stop_find(wpa_s);
  4272. for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
  4273. if (wpa_s == global->p2p_group_formation &&
  4274. (wpa_s->p2p_in_provisioning ||
  4275. wpa_s->parent->pending_interface_type ==
  4276. WPA_IF_P2P_CLIENT)) {
  4277. wpa_printf(MSG_DEBUG, "P2P: Interface %s in group "
  4278. "formation found - cancelling",
  4279. wpa_s->ifname);
  4280. found = 1;
  4281. eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
  4282. wpa_s->parent, NULL);
  4283. if (wpa_s->p2p_in_provisioning) {
  4284. wpas_group_formation_completed(wpa_s, 0);
  4285. break;
  4286. }
  4287. wpas_p2p_group_delete(wpa_s,
  4288. P2P_GROUP_REMOVAL_REQUESTED);
  4289. break;
  4290. }
  4291. }
  4292. if (!found) {
  4293. wpa_printf(MSG_DEBUG, "P2P: No ongoing group formation found");
  4294. return -1;
  4295. }
  4296. return 0;
  4297. }
  4298. void wpas_p2p_interface_unavailable(struct wpa_supplicant *wpa_s)
  4299. {
  4300. if (wpa_s->current_ssid == NULL || !wpa_s->current_ssid->p2p_group)
  4301. return;
  4302. wpa_printf(MSG_DEBUG, "P2P: Remove group due to driver resource not "
  4303. "being available anymore");
  4304. wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_UNAVAILABLE);
  4305. }
  4306. void wpas_p2p_update_best_channels(struct wpa_supplicant *wpa_s,
  4307. int freq_24, int freq_5, int freq_overall)
  4308. {
  4309. struct p2p_data *p2p = wpa_s->global->p2p;
  4310. if (p2p == NULL || (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT))
  4311. return;
  4312. p2p_set_best_channels(p2p, freq_24, freq_5, freq_overall);
  4313. }
  4314. int wpas_p2p_unauthorize(struct wpa_supplicant *wpa_s, const char *addr)
  4315. {
  4316. u8 peer[ETH_ALEN];
  4317. struct p2p_data *p2p = wpa_s->global->p2p;
  4318. if (p2p == NULL || (wpa_s->drv_flags & WPA_DRIVER_FLAGS_P2P_MGMT))
  4319. return -1;
  4320. if (hwaddr_aton(addr, peer))
  4321. return -1;
  4322. return p2p_unauthorize(p2p, peer);
  4323. }
  4324. /**
  4325. * wpas_p2p_disconnect - Disconnect from a P2P Group
  4326. * @wpa_s: Pointer to wpa_supplicant data
  4327. * Returns: 0 on success, -1 on failure
  4328. *
  4329. * This can be used to disconnect from a group in which the local end is a P2P
  4330. * Client or to end a P2P Group in case the local end is the Group Owner. If a
  4331. * virtual network interface was created for this group, that interface will be
  4332. * removed. Otherwise, only the configured P2P group network will be removed
  4333. * from the interface.
  4334. */
  4335. int wpas_p2p_disconnect(struct wpa_supplicant *wpa_s)
  4336. {
  4337. if (wpa_s == NULL)
  4338. return -1;
  4339. return wpas_p2p_group_delete(wpa_s, P2P_GROUP_REMOVAL_REQUESTED) < 0 ?
  4340. -1 : 0;
  4341. }
  4342. int wpas_p2p_in_progress(struct wpa_supplicant *wpa_s)
  4343. {
  4344. if (wpa_s->global->p2p_disabled || wpa_s->global->p2p == NULL)
  4345. return 0;
  4346. return p2p_in_progress(wpa_s->global->p2p);
  4347. }
  4348. void wpas_p2p_network_removed(struct wpa_supplicant *wpa_s,
  4349. struct wpa_ssid *ssid)
  4350. {
  4351. if (wpa_s->p2p_in_provisioning && ssid->p2p_group &&
  4352. eloop_cancel_timeout(wpas_p2p_group_formation_timeout,
  4353. wpa_s->parent, NULL) > 0) {
  4354. /**
  4355. * Remove the network by scheduling the group formation
  4356. * timeout to happen immediately. The teardown code
  4357. * needs to be scheduled to run asynch later so that we
  4358. * don't delete data from under ourselves unexpectedly.
  4359. * Calling wpas_p2p_group_formation_timeout directly
  4360. * causes a series of crashes in WPS failure scenarios.
  4361. */
  4362. wpa_printf(MSG_DEBUG, "P2P: Canceled group formation due to "
  4363. "P2P group network getting removed");
  4364. eloop_register_timeout(0, 0, wpas_p2p_group_formation_timeout,
  4365. wpa_s->parent, NULL);
  4366. }
  4367. }
  4368. struct wpa_ssid * wpas_p2p_get_persistent(struct wpa_supplicant *wpa_s,
  4369. const u8 *addr, const u8 *ssid,
  4370. size_t ssid_len)
  4371. {
  4372. struct wpa_ssid *s;
  4373. size_t i;
  4374. for (s = wpa_s->conf->ssid; s; s = s->next) {
  4375. if (s->disabled != 2)
  4376. continue;
  4377. if (ssid &&
  4378. (ssid_len != s->ssid_len ||
  4379. os_memcmp(ssid, s->ssid, ssid_len) != 0))
  4380. continue;
  4381. if (os_memcmp(s->bssid, addr, ETH_ALEN) == 0)
  4382. return s; /* peer is GO in the persistent group */
  4383. if (s->mode != WPAS_MODE_P2P_GO || s->p2p_client_list == NULL)
  4384. continue;
  4385. for (i = 0; i < s->num_p2p_clients; i++) {
  4386. if (os_memcmp(s->p2p_client_list + i * ETH_ALEN,
  4387. addr, ETH_ALEN) == 0)
  4388. return s; /* peer is P2P client in persistent
  4389. * group */
  4390. }
  4391. }
  4392. return NULL;
  4393. }
  4394. void wpas_p2p_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
  4395. const u8 *addr)
  4396. {
  4397. if (addr == NULL)
  4398. return;
  4399. wpas_p2p_add_persistent_group_client(wpa_s, addr);
  4400. }
  4401. static void wpas_p2p_fallback_to_go_neg(struct wpa_supplicant *wpa_s,
  4402. int group_added)
  4403. {
  4404. struct wpa_supplicant *group = wpa_s;
  4405. eloop_cancel_timeout(wpas_p2p_pd_before_join_timeout, wpa_s, NULL);
  4406. if (wpa_s->global->p2p_group_formation)
  4407. group = wpa_s->global->p2p_group_formation;
  4408. wpa_s = wpa_s->parent;
  4409. offchannel_send_action_done(wpa_s);
  4410. if (group_added)
  4411. wpas_p2p_group_delete(group, P2P_GROUP_REMOVAL_SILENT);
  4412. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Fall back to GO Negotiation");
  4413. wpas_p2p_connect(wpa_s, wpa_s->pending_join_dev_addr, wpa_s->p2p_pin,
  4414. wpa_s->p2p_wps_method, wpa_s->p2p_persistent_group, 0,
  4415. 0, 0, wpa_s->p2p_go_intent, wpa_s->p2p_connect_freq,
  4416. wpa_s->p2p_persistent_id,
  4417. wpa_s->p2p_pd_before_go_neg,
  4418. wpa_s->p2p_go_ht40);
  4419. }
  4420. int wpas_p2p_scan_no_go_seen(struct wpa_supplicant *wpa_s)
  4421. {
  4422. if (!wpa_s->p2p_fallback_to_go_neg ||
  4423. wpa_s->p2p_in_provisioning <= 5)
  4424. return 0;
  4425. if (wpas_p2p_peer_go(wpa_s, wpa_s->pending_join_dev_addr) > 0)
  4426. return 0; /* peer operating as a GO */
  4427. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: GO not found for p2p_connect-auto - "
  4428. "fallback to GO Negotiation");
  4429. wpas_p2p_fallback_to_go_neg(wpa_s, 1);
  4430. return 1;
  4431. }
  4432. unsigned int wpas_p2p_search_delay(struct wpa_supplicant *wpa_s)
  4433. {
  4434. const char *rn, *rn2;
  4435. struct wpa_supplicant *ifs;
  4436. if (wpa_s->wpa_state > WPA_SCANNING) {
  4437. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search delay due to "
  4438. "concurrent operation",
  4439. P2P_CONCURRENT_SEARCH_DELAY);
  4440. return P2P_CONCURRENT_SEARCH_DELAY;
  4441. }
  4442. if (!wpa_s->driver->get_radio_name)
  4443. return 0;
  4444. rn = wpa_s->driver->get_radio_name(wpa_s->drv_priv);
  4445. if (rn == NULL || rn[0] == '\0')
  4446. return 0;
  4447. for (ifs = wpa_s->global->ifaces; ifs; ifs = ifs->next) {
  4448. if (ifs == wpa_s || !ifs->driver->get_radio_name)
  4449. continue;
  4450. rn2 = ifs->driver->get_radio_name(ifs->drv_priv);
  4451. if (!rn2 || os_strcmp(rn, rn2) != 0)
  4452. continue;
  4453. if (ifs->wpa_state > WPA_SCANNING) {
  4454. wpa_dbg(wpa_s, MSG_DEBUG, "P2P: Use %u ms search "
  4455. "delay due to concurrent operation on "
  4456. "interface %s",
  4457. P2P_CONCURRENT_SEARCH_DELAY, ifs->ifname);
  4458. return P2P_CONCURRENT_SEARCH_DELAY;
  4459. }
  4460. }
  4461. return 0;
  4462. }