af_key.c 101 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822
  1. /*
  2. * net/key/af_key.c An implementation of PF_KEYv2 sockets.
  3. *
  4. * This program is free software; you can redistribute it and/or
  5. * modify it under the terms of the GNU General Public License
  6. * as published by the Free Software Foundation; either version
  7. * 2 of the License, or (at your option) any later version.
  8. *
  9. * Authors: Maxim Giryaev <gem@asplinux.ru>
  10. * David S. Miller <davem@redhat.com>
  11. * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
  12. * Kunihiro Ishiguro <kunihiro@ipinfusion.com>
  13. * Kazunori MIYAZAWA / USAGI Project <miyazawa@linux-ipv6.org>
  14. * Derek Atkins <derek@ihtfp.com>
  15. */
  16. #include <linux/capability.h>
  17. #include <linux/module.h>
  18. #include <linux/kernel.h>
  19. #include <linux/socket.h>
  20. #include <linux/pfkeyv2.h>
  21. #include <linux/ipsec.h>
  22. #include <linux/skbuff.h>
  23. #include <linux/rtnetlink.h>
  24. #include <linux/in.h>
  25. #include <linux/in6.h>
  26. #include <linux/proc_fs.h>
  27. #include <linux/init.h>
  28. #include <net/net_namespace.h>
  29. #include <net/xfrm.h>
  30. #include <net/sock.h>
  31. #define _X2KEY(x) ((x) == XFRM_INF ? 0 : (x))
  32. #define _KEY2X(x) ((x) == 0 ? XFRM_INF : (x))
  33. /* List of all pfkey sockets. */
  34. static HLIST_HEAD(pfkey_table);
  35. static DECLARE_WAIT_QUEUE_HEAD(pfkey_table_wait);
  36. static DEFINE_RWLOCK(pfkey_table_lock);
  37. static atomic_t pfkey_table_users = ATOMIC_INIT(0);
  38. static atomic_t pfkey_socks_nr = ATOMIC_INIT(0);
  39. struct pfkey_sock {
  40. /* struct sock must be the first member of struct pfkey_sock */
  41. struct sock sk;
  42. int registered;
  43. int promisc;
  44. };
  45. static inline struct pfkey_sock *pfkey_sk(struct sock *sk)
  46. {
  47. return (struct pfkey_sock *)sk;
  48. }
  49. static void pfkey_sock_destruct(struct sock *sk)
  50. {
  51. skb_queue_purge(&sk->sk_receive_queue);
  52. if (!sock_flag(sk, SOCK_DEAD)) {
  53. printk("Attempt to release alive pfkey socket: %p\n", sk);
  54. return;
  55. }
  56. BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
  57. BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
  58. atomic_dec(&pfkey_socks_nr);
  59. }
  60. static void pfkey_table_grab(void)
  61. {
  62. write_lock_bh(&pfkey_table_lock);
  63. if (atomic_read(&pfkey_table_users)) {
  64. DECLARE_WAITQUEUE(wait, current);
  65. add_wait_queue_exclusive(&pfkey_table_wait, &wait);
  66. for(;;) {
  67. set_current_state(TASK_UNINTERRUPTIBLE);
  68. if (atomic_read(&pfkey_table_users) == 0)
  69. break;
  70. write_unlock_bh(&pfkey_table_lock);
  71. schedule();
  72. write_lock_bh(&pfkey_table_lock);
  73. }
  74. __set_current_state(TASK_RUNNING);
  75. remove_wait_queue(&pfkey_table_wait, &wait);
  76. }
  77. }
  78. static __inline__ void pfkey_table_ungrab(void)
  79. {
  80. write_unlock_bh(&pfkey_table_lock);
  81. wake_up(&pfkey_table_wait);
  82. }
  83. static __inline__ void pfkey_lock_table(void)
  84. {
  85. /* read_lock() synchronizes us to pfkey_table_grab */
  86. read_lock(&pfkey_table_lock);
  87. atomic_inc(&pfkey_table_users);
  88. read_unlock(&pfkey_table_lock);
  89. }
  90. static __inline__ void pfkey_unlock_table(void)
  91. {
  92. if (atomic_dec_and_test(&pfkey_table_users))
  93. wake_up(&pfkey_table_wait);
  94. }
  95. static const struct proto_ops pfkey_ops;
  96. static void pfkey_insert(struct sock *sk)
  97. {
  98. pfkey_table_grab();
  99. sk_add_node(sk, &pfkey_table);
  100. pfkey_table_ungrab();
  101. }
  102. static void pfkey_remove(struct sock *sk)
  103. {
  104. pfkey_table_grab();
  105. sk_del_node_init(sk);
  106. pfkey_table_ungrab();
  107. }
  108. static struct proto key_proto = {
  109. .name = "KEY",
  110. .owner = THIS_MODULE,
  111. .obj_size = sizeof(struct pfkey_sock),
  112. };
  113. static int pfkey_create(struct net *net, struct socket *sock, int protocol)
  114. {
  115. struct sock *sk;
  116. int err;
  117. if (net != &init_net)
  118. return -EAFNOSUPPORT;
  119. if (!capable(CAP_NET_ADMIN))
  120. return -EPERM;
  121. if (sock->type != SOCK_RAW)
  122. return -ESOCKTNOSUPPORT;
  123. if (protocol != PF_KEY_V2)
  124. return -EPROTONOSUPPORT;
  125. err = -ENOMEM;
  126. sk = sk_alloc(net, PF_KEY, GFP_KERNEL, &key_proto, 1);
  127. if (sk == NULL)
  128. goto out;
  129. sock->ops = &pfkey_ops;
  130. sock_init_data(sock, sk);
  131. sk->sk_family = PF_KEY;
  132. sk->sk_destruct = pfkey_sock_destruct;
  133. atomic_inc(&pfkey_socks_nr);
  134. pfkey_insert(sk);
  135. return 0;
  136. out:
  137. return err;
  138. }
  139. static int pfkey_release(struct socket *sock)
  140. {
  141. struct sock *sk = sock->sk;
  142. if (!sk)
  143. return 0;
  144. pfkey_remove(sk);
  145. sock_orphan(sk);
  146. sock->sk = NULL;
  147. skb_queue_purge(&sk->sk_write_queue);
  148. sock_put(sk);
  149. return 0;
  150. }
  151. static int pfkey_broadcast_one(struct sk_buff *skb, struct sk_buff **skb2,
  152. gfp_t allocation, struct sock *sk)
  153. {
  154. int err = -ENOBUFS;
  155. sock_hold(sk);
  156. if (*skb2 == NULL) {
  157. if (atomic_read(&skb->users) != 1) {
  158. *skb2 = skb_clone(skb, allocation);
  159. } else {
  160. *skb2 = skb;
  161. atomic_inc(&skb->users);
  162. }
  163. }
  164. if (*skb2 != NULL) {
  165. if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf) {
  166. skb_orphan(*skb2);
  167. skb_set_owner_r(*skb2, sk);
  168. skb_queue_tail(&sk->sk_receive_queue, *skb2);
  169. sk->sk_data_ready(sk, (*skb2)->len);
  170. *skb2 = NULL;
  171. err = 0;
  172. }
  173. }
  174. sock_put(sk);
  175. return err;
  176. }
  177. /* Send SKB to all pfkey sockets matching selected criteria. */
  178. #define BROADCAST_ALL 0
  179. #define BROADCAST_ONE 1
  180. #define BROADCAST_REGISTERED 2
  181. #define BROADCAST_PROMISC_ONLY 4
  182. static int pfkey_broadcast(struct sk_buff *skb, gfp_t allocation,
  183. int broadcast_flags, struct sock *one_sk)
  184. {
  185. struct sock *sk;
  186. struct hlist_node *node;
  187. struct sk_buff *skb2 = NULL;
  188. int err = -ESRCH;
  189. /* XXX Do we need something like netlink_overrun? I think
  190. * XXX PF_KEY socket apps will not mind current behavior.
  191. */
  192. if (!skb)
  193. return -ENOMEM;
  194. pfkey_lock_table();
  195. sk_for_each(sk, node, &pfkey_table) {
  196. struct pfkey_sock *pfk = pfkey_sk(sk);
  197. int err2;
  198. /* Yes, it means that if you are meant to receive this
  199. * pfkey message you receive it twice as promiscuous
  200. * socket.
  201. */
  202. if (pfk->promisc)
  203. pfkey_broadcast_one(skb, &skb2, allocation, sk);
  204. /* the exact target will be processed later */
  205. if (sk == one_sk)
  206. continue;
  207. if (broadcast_flags != BROADCAST_ALL) {
  208. if (broadcast_flags & BROADCAST_PROMISC_ONLY)
  209. continue;
  210. if ((broadcast_flags & BROADCAST_REGISTERED) &&
  211. !pfk->registered)
  212. continue;
  213. if (broadcast_flags & BROADCAST_ONE)
  214. continue;
  215. }
  216. err2 = pfkey_broadcast_one(skb, &skb2, allocation, sk);
  217. /* Error is cleare after succecful sending to at least one
  218. * registered KM */
  219. if ((broadcast_flags & BROADCAST_REGISTERED) && err)
  220. err = err2;
  221. }
  222. pfkey_unlock_table();
  223. if (one_sk != NULL)
  224. err = pfkey_broadcast_one(skb, &skb2, allocation, one_sk);
  225. if (skb2)
  226. kfree_skb(skb2);
  227. kfree_skb(skb);
  228. return err;
  229. }
  230. static inline void pfkey_hdr_dup(struct sadb_msg *new, struct sadb_msg *orig)
  231. {
  232. *new = *orig;
  233. }
  234. static int pfkey_error(struct sadb_msg *orig, int err, struct sock *sk)
  235. {
  236. struct sk_buff *skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_KERNEL);
  237. struct sadb_msg *hdr;
  238. if (!skb)
  239. return -ENOBUFS;
  240. /* Woe be to the platform trying to support PFKEY yet
  241. * having normal errnos outside the 1-255 range, inclusive.
  242. */
  243. err = -err;
  244. if (err == ERESTARTSYS ||
  245. err == ERESTARTNOHAND ||
  246. err == ERESTARTNOINTR)
  247. err = EINTR;
  248. if (err >= 512)
  249. err = EINVAL;
  250. BUG_ON(err <= 0 || err >= 256);
  251. hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
  252. pfkey_hdr_dup(hdr, orig);
  253. hdr->sadb_msg_errno = (uint8_t) err;
  254. hdr->sadb_msg_len = (sizeof(struct sadb_msg) /
  255. sizeof(uint64_t));
  256. pfkey_broadcast(skb, GFP_KERNEL, BROADCAST_ONE, sk);
  257. return 0;
  258. }
  259. static u8 sadb_ext_min_len[] = {
  260. [SADB_EXT_RESERVED] = (u8) 0,
  261. [SADB_EXT_SA] = (u8) sizeof(struct sadb_sa),
  262. [SADB_EXT_LIFETIME_CURRENT] = (u8) sizeof(struct sadb_lifetime),
  263. [SADB_EXT_LIFETIME_HARD] = (u8) sizeof(struct sadb_lifetime),
  264. [SADB_EXT_LIFETIME_SOFT] = (u8) sizeof(struct sadb_lifetime),
  265. [SADB_EXT_ADDRESS_SRC] = (u8) sizeof(struct sadb_address),
  266. [SADB_EXT_ADDRESS_DST] = (u8) sizeof(struct sadb_address),
  267. [SADB_EXT_ADDRESS_PROXY] = (u8) sizeof(struct sadb_address),
  268. [SADB_EXT_KEY_AUTH] = (u8) sizeof(struct sadb_key),
  269. [SADB_EXT_KEY_ENCRYPT] = (u8) sizeof(struct sadb_key),
  270. [SADB_EXT_IDENTITY_SRC] = (u8) sizeof(struct sadb_ident),
  271. [SADB_EXT_IDENTITY_DST] = (u8) sizeof(struct sadb_ident),
  272. [SADB_EXT_SENSITIVITY] = (u8) sizeof(struct sadb_sens),
  273. [SADB_EXT_PROPOSAL] = (u8) sizeof(struct sadb_prop),
  274. [SADB_EXT_SUPPORTED_AUTH] = (u8) sizeof(struct sadb_supported),
  275. [SADB_EXT_SUPPORTED_ENCRYPT] = (u8) sizeof(struct sadb_supported),
  276. [SADB_EXT_SPIRANGE] = (u8) sizeof(struct sadb_spirange),
  277. [SADB_X_EXT_KMPRIVATE] = (u8) sizeof(struct sadb_x_kmprivate),
  278. [SADB_X_EXT_POLICY] = (u8) sizeof(struct sadb_x_policy),
  279. [SADB_X_EXT_SA2] = (u8) sizeof(struct sadb_x_sa2),
  280. [SADB_X_EXT_NAT_T_TYPE] = (u8) sizeof(struct sadb_x_nat_t_type),
  281. [SADB_X_EXT_NAT_T_SPORT] = (u8) sizeof(struct sadb_x_nat_t_port),
  282. [SADB_X_EXT_NAT_T_DPORT] = (u8) sizeof(struct sadb_x_nat_t_port),
  283. [SADB_X_EXT_NAT_T_OA] = (u8) sizeof(struct sadb_address),
  284. [SADB_X_EXT_SEC_CTX] = (u8) sizeof(struct sadb_x_sec_ctx),
  285. };
  286. /* Verify sadb_address_{len,prefixlen} against sa_family. */
  287. static int verify_address_len(void *p)
  288. {
  289. struct sadb_address *sp = p;
  290. struct sockaddr *addr = (struct sockaddr *)(sp + 1);
  291. struct sockaddr_in *sin;
  292. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  293. struct sockaddr_in6 *sin6;
  294. #endif
  295. int len;
  296. switch (addr->sa_family) {
  297. case AF_INET:
  298. len = DIV_ROUND_UP(sizeof(*sp) + sizeof(*sin), sizeof(uint64_t));
  299. if (sp->sadb_address_len != len ||
  300. sp->sadb_address_prefixlen > 32)
  301. return -EINVAL;
  302. break;
  303. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  304. case AF_INET6:
  305. len = DIV_ROUND_UP(sizeof(*sp) + sizeof(*sin6), sizeof(uint64_t));
  306. if (sp->sadb_address_len != len ||
  307. sp->sadb_address_prefixlen > 128)
  308. return -EINVAL;
  309. break;
  310. #endif
  311. default:
  312. /* It is user using kernel to keep track of security
  313. * associations for another protocol, such as
  314. * OSPF/RSVP/RIPV2/MIP. It is user's job to verify
  315. * lengths.
  316. *
  317. * XXX Actually, association/policy database is not yet
  318. * XXX able to cope with arbitrary sockaddr families.
  319. * XXX When it can, remove this -EINVAL. -DaveM
  320. */
  321. return -EINVAL;
  322. break;
  323. }
  324. return 0;
  325. }
  326. static inline int pfkey_sec_ctx_len(struct sadb_x_sec_ctx *sec_ctx)
  327. {
  328. return DIV_ROUND_UP(sizeof(struct sadb_x_sec_ctx) +
  329. sec_ctx->sadb_x_ctx_len,
  330. sizeof(uint64_t));
  331. }
  332. static inline int verify_sec_ctx_len(void *p)
  333. {
  334. struct sadb_x_sec_ctx *sec_ctx = (struct sadb_x_sec_ctx *)p;
  335. int len;
  336. if (sec_ctx->sadb_x_ctx_len > PAGE_SIZE)
  337. return -EINVAL;
  338. len = pfkey_sec_ctx_len(sec_ctx);
  339. if (sec_ctx->sadb_x_sec_len != len)
  340. return -EINVAL;
  341. return 0;
  342. }
  343. static inline struct xfrm_user_sec_ctx *pfkey_sadb2xfrm_user_sec_ctx(struct sadb_x_sec_ctx *sec_ctx)
  344. {
  345. struct xfrm_user_sec_ctx *uctx = NULL;
  346. int ctx_size = sec_ctx->sadb_x_ctx_len;
  347. uctx = kmalloc((sizeof(*uctx)+ctx_size), GFP_KERNEL);
  348. if (!uctx)
  349. return NULL;
  350. uctx->len = pfkey_sec_ctx_len(sec_ctx);
  351. uctx->exttype = sec_ctx->sadb_x_sec_exttype;
  352. uctx->ctx_doi = sec_ctx->sadb_x_ctx_doi;
  353. uctx->ctx_alg = sec_ctx->sadb_x_ctx_alg;
  354. uctx->ctx_len = sec_ctx->sadb_x_ctx_len;
  355. memcpy(uctx + 1, sec_ctx + 1,
  356. uctx->ctx_len);
  357. return uctx;
  358. }
  359. static int present_and_same_family(struct sadb_address *src,
  360. struct sadb_address *dst)
  361. {
  362. struct sockaddr *s_addr, *d_addr;
  363. if (!src || !dst)
  364. return 0;
  365. s_addr = (struct sockaddr *)(src + 1);
  366. d_addr = (struct sockaddr *)(dst + 1);
  367. if (s_addr->sa_family != d_addr->sa_family)
  368. return 0;
  369. if (s_addr->sa_family != AF_INET
  370. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  371. && s_addr->sa_family != AF_INET6
  372. #endif
  373. )
  374. return 0;
  375. return 1;
  376. }
  377. static int parse_exthdrs(struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  378. {
  379. char *p = (char *) hdr;
  380. int len = skb->len;
  381. len -= sizeof(*hdr);
  382. p += sizeof(*hdr);
  383. while (len > 0) {
  384. struct sadb_ext *ehdr = (struct sadb_ext *) p;
  385. uint16_t ext_type;
  386. int ext_len;
  387. ext_len = ehdr->sadb_ext_len;
  388. ext_len *= sizeof(uint64_t);
  389. ext_type = ehdr->sadb_ext_type;
  390. if (ext_len < sizeof(uint64_t) ||
  391. ext_len > len ||
  392. ext_type == SADB_EXT_RESERVED)
  393. return -EINVAL;
  394. if (ext_type <= SADB_EXT_MAX) {
  395. int min = (int) sadb_ext_min_len[ext_type];
  396. if (ext_len < min)
  397. return -EINVAL;
  398. if (ext_hdrs[ext_type-1] != NULL)
  399. return -EINVAL;
  400. if (ext_type == SADB_EXT_ADDRESS_SRC ||
  401. ext_type == SADB_EXT_ADDRESS_DST ||
  402. ext_type == SADB_EXT_ADDRESS_PROXY ||
  403. ext_type == SADB_X_EXT_NAT_T_OA) {
  404. if (verify_address_len(p))
  405. return -EINVAL;
  406. }
  407. if (ext_type == SADB_X_EXT_SEC_CTX) {
  408. if (verify_sec_ctx_len(p))
  409. return -EINVAL;
  410. }
  411. ext_hdrs[ext_type-1] = p;
  412. }
  413. p += ext_len;
  414. len -= ext_len;
  415. }
  416. return 0;
  417. }
  418. static uint16_t
  419. pfkey_satype2proto(uint8_t satype)
  420. {
  421. switch (satype) {
  422. case SADB_SATYPE_UNSPEC:
  423. return IPSEC_PROTO_ANY;
  424. case SADB_SATYPE_AH:
  425. return IPPROTO_AH;
  426. case SADB_SATYPE_ESP:
  427. return IPPROTO_ESP;
  428. case SADB_X_SATYPE_IPCOMP:
  429. return IPPROTO_COMP;
  430. break;
  431. default:
  432. return 0;
  433. }
  434. /* NOTREACHED */
  435. }
  436. static uint8_t
  437. pfkey_proto2satype(uint16_t proto)
  438. {
  439. switch (proto) {
  440. case IPPROTO_AH:
  441. return SADB_SATYPE_AH;
  442. case IPPROTO_ESP:
  443. return SADB_SATYPE_ESP;
  444. case IPPROTO_COMP:
  445. return SADB_X_SATYPE_IPCOMP;
  446. break;
  447. default:
  448. return 0;
  449. }
  450. /* NOTREACHED */
  451. }
  452. /* BTW, this scheme means that there is no way with PFKEY2 sockets to
  453. * say specifically 'just raw sockets' as we encode them as 255.
  454. */
  455. static uint8_t pfkey_proto_to_xfrm(uint8_t proto)
  456. {
  457. return (proto == IPSEC_PROTO_ANY ? 0 : proto);
  458. }
  459. static uint8_t pfkey_proto_from_xfrm(uint8_t proto)
  460. {
  461. return (proto ? proto : IPSEC_PROTO_ANY);
  462. }
  463. static int pfkey_sadb_addr2xfrm_addr(struct sadb_address *addr,
  464. xfrm_address_t *xaddr)
  465. {
  466. switch (((struct sockaddr*)(addr + 1))->sa_family) {
  467. case AF_INET:
  468. xaddr->a4 =
  469. ((struct sockaddr_in *)(addr + 1))->sin_addr.s_addr;
  470. return AF_INET;
  471. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  472. case AF_INET6:
  473. memcpy(xaddr->a6,
  474. &((struct sockaddr_in6 *)(addr + 1))->sin6_addr,
  475. sizeof(struct in6_addr));
  476. return AF_INET6;
  477. #endif
  478. default:
  479. return 0;
  480. }
  481. /* NOTREACHED */
  482. }
  483. static struct xfrm_state *pfkey_xfrm_state_lookup(struct sadb_msg *hdr, void **ext_hdrs)
  484. {
  485. struct sadb_sa *sa;
  486. struct sadb_address *addr;
  487. uint16_t proto;
  488. unsigned short family;
  489. xfrm_address_t *xaddr;
  490. sa = (struct sadb_sa *) ext_hdrs[SADB_EXT_SA-1];
  491. if (sa == NULL)
  492. return NULL;
  493. proto = pfkey_satype2proto(hdr->sadb_msg_satype);
  494. if (proto == 0)
  495. return NULL;
  496. /* sadb_address_len should be checked by caller */
  497. addr = (struct sadb_address *) ext_hdrs[SADB_EXT_ADDRESS_DST-1];
  498. if (addr == NULL)
  499. return NULL;
  500. family = ((struct sockaddr *)(addr + 1))->sa_family;
  501. switch (family) {
  502. case AF_INET:
  503. xaddr = (xfrm_address_t *)&((struct sockaddr_in *)(addr + 1))->sin_addr;
  504. break;
  505. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  506. case AF_INET6:
  507. xaddr = (xfrm_address_t *)&((struct sockaddr_in6 *)(addr + 1))->sin6_addr;
  508. break;
  509. #endif
  510. default:
  511. xaddr = NULL;
  512. }
  513. if (!xaddr)
  514. return NULL;
  515. return xfrm_state_lookup(xaddr, sa->sadb_sa_spi, proto, family);
  516. }
  517. #define PFKEY_ALIGN8(a) (1 + (((a) - 1) | (8 - 1)))
  518. static int
  519. pfkey_sockaddr_size(sa_family_t family)
  520. {
  521. switch (family) {
  522. case AF_INET:
  523. return PFKEY_ALIGN8(sizeof(struct sockaddr_in));
  524. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  525. case AF_INET6:
  526. return PFKEY_ALIGN8(sizeof(struct sockaddr_in6));
  527. #endif
  528. default:
  529. return 0;
  530. }
  531. /* NOTREACHED */
  532. }
  533. static inline int pfkey_mode_from_xfrm(int mode)
  534. {
  535. switch(mode) {
  536. case XFRM_MODE_TRANSPORT:
  537. return IPSEC_MODE_TRANSPORT;
  538. case XFRM_MODE_TUNNEL:
  539. return IPSEC_MODE_TUNNEL;
  540. case XFRM_MODE_BEET:
  541. return IPSEC_MODE_BEET;
  542. default:
  543. return -1;
  544. }
  545. }
  546. static inline int pfkey_mode_to_xfrm(int mode)
  547. {
  548. switch(mode) {
  549. case IPSEC_MODE_ANY: /*XXX*/
  550. case IPSEC_MODE_TRANSPORT:
  551. return XFRM_MODE_TRANSPORT;
  552. case IPSEC_MODE_TUNNEL:
  553. return XFRM_MODE_TUNNEL;
  554. case IPSEC_MODE_BEET:
  555. return XFRM_MODE_BEET;
  556. default:
  557. return -1;
  558. }
  559. }
  560. static struct sk_buff * pfkey_xfrm_state2msg(struct xfrm_state *x, int add_keys, int hsc)
  561. {
  562. struct sk_buff *skb;
  563. struct sadb_msg *hdr;
  564. struct sadb_sa *sa;
  565. struct sadb_lifetime *lifetime;
  566. struct sadb_address *addr;
  567. struct sadb_key *key;
  568. struct sadb_x_sa2 *sa2;
  569. struct sockaddr_in *sin;
  570. struct sadb_x_sec_ctx *sec_ctx;
  571. struct xfrm_sec_ctx *xfrm_ctx;
  572. int ctx_size = 0;
  573. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  574. struct sockaddr_in6 *sin6;
  575. #endif
  576. int size;
  577. int auth_key_size = 0;
  578. int encrypt_key_size = 0;
  579. int sockaddr_size;
  580. struct xfrm_encap_tmpl *natt = NULL;
  581. int mode;
  582. /* address family check */
  583. sockaddr_size = pfkey_sockaddr_size(x->props.family);
  584. if (!sockaddr_size)
  585. return ERR_PTR(-EINVAL);
  586. /* base, SA, (lifetime (HSC),) address(SD), (address(P),)
  587. key(AE), (identity(SD),) (sensitivity)> */
  588. size = sizeof(struct sadb_msg) +sizeof(struct sadb_sa) +
  589. sizeof(struct sadb_lifetime) +
  590. ((hsc & 1) ? sizeof(struct sadb_lifetime) : 0) +
  591. ((hsc & 2) ? sizeof(struct sadb_lifetime) : 0) +
  592. sizeof(struct sadb_address)*2 +
  593. sockaddr_size*2 +
  594. sizeof(struct sadb_x_sa2);
  595. if ((xfrm_ctx = x->security)) {
  596. ctx_size = PFKEY_ALIGN8(xfrm_ctx->ctx_len);
  597. size += sizeof(struct sadb_x_sec_ctx) + ctx_size;
  598. }
  599. /* identity & sensitivity */
  600. if ((x->props.family == AF_INET &&
  601. x->sel.saddr.a4 != x->props.saddr.a4)
  602. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  603. || (x->props.family == AF_INET6 &&
  604. memcmp (x->sel.saddr.a6, x->props.saddr.a6, sizeof (struct in6_addr)))
  605. #endif
  606. )
  607. size += sizeof(struct sadb_address) + sockaddr_size;
  608. if (add_keys) {
  609. if (x->aalg && x->aalg->alg_key_len) {
  610. auth_key_size =
  611. PFKEY_ALIGN8((x->aalg->alg_key_len + 7) / 8);
  612. size += sizeof(struct sadb_key) + auth_key_size;
  613. }
  614. if (x->ealg && x->ealg->alg_key_len) {
  615. encrypt_key_size =
  616. PFKEY_ALIGN8((x->ealg->alg_key_len+7) / 8);
  617. size += sizeof(struct sadb_key) + encrypt_key_size;
  618. }
  619. }
  620. if (x->encap)
  621. natt = x->encap;
  622. if (natt && natt->encap_type) {
  623. size += sizeof(struct sadb_x_nat_t_type);
  624. size += sizeof(struct sadb_x_nat_t_port);
  625. size += sizeof(struct sadb_x_nat_t_port);
  626. }
  627. skb = alloc_skb(size + 16, GFP_ATOMIC);
  628. if (skb == NULL)
  629. return ERR_PTR(-ENOBUFS);
  630. /* call should fill header later */
  631. hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
  632. memset(hdr, 0, size); /* XXX do we need this ? */
  633. hdr->sadb_msg_len = size / sizeof(uint64_t);
  634. /* sa */
  635. sa = (struct sadb_sa *) skb_put(skb, sizeof(struct sadb_sa));
  636. sa->sadb_sa_len = sizeof(struct sadb_sa)/sizeof(uint64_t);
  637. sa->sadb_sa_exttype = SADB_EXT_SA;
  638. sa->sadb_sa_spi = x->id.spi;
  639. sa->sadb_sa_replay = x->props.replay_window;
  640. switch (x->km.state) {
  641. case XFRM_STATE_VALID:
  642. sa->sadb_sa_state = x->km.dying ?
  643. SADB_SASTATE_DYING : SADB_SASTATE_MATURE;
  644. break;
  645. case XFRM_STATE_ACQ:
  646. sa->sadb_sa_state = SADB_SASTATE_LARVAL;
  647. break;
  648. default:
  649. sa->sadb_sa_state = SADB_SASTATE_DEAD;
  650. break;
  651. }
  652. sa->sadb_sa_auth = 0;
  653. if (x->aalg) {
  654. struct xfrm_algo_desc *a = xfrm_aalg_get_byname(x->aalg->alg_name, 0);
  655. sa->sadb_sa_auth = a ? a->desc.sadb_alg_id : 0;
  656. }
  657. sa->sadb_sa_encrypt = 0;
  658. BUG_ON(x->ealg && x->calg);
  659. if (x->ealg) {
  660. struct xfrm_algo_desc *a = xfrm_ealg_get_byname(x->ealg->alg_name, 0);
  661. sa->sadb_sa_encrypt = a ? a->desc.sadb_alg_id : 0;
  662. }
  663. /* KAME compatible: sadb_sa_encrypt is overloaded with calg id */
  664. if (x->calg) {
  665. struct xfrm_algo_desc *a = xfrm_calg_get_byname(x->calg->alg_name, 0);
  666. sa->sadb_sa_encrypt = a ? a->desc.sadb_alg_id : 0;
  667. }
  668. sa->sadb_sa_flags = 0;
  669. if (x->props.flags & XFRM_STATE_NOECN)
  670. sa->sadb_sa_flags |= SADB_SAFLAGS_NOECN;
  671. if (x->props.flags & XFRM_STATE_DECAP_DSCP)
  672. sa->sadb_sa_flags |= SADB_SAFLAGS_DECAP_DSCP;
  673. if (x->props.flags & XFRM_STATE_NOPMTUDISC)
  674. sa->sadb_sa_flags |= SADB_SAFLAGS_NOPMTUDISC;
  675. /* hard time */
  676. if (hsc & 2) {
  677. lifetime = (struct sadb_lifetime *) skb_put(skb,
  678. sizeof(struct sadb_lifetime));
  679. lifetime->sadb_lifetime_len =
  680. sizeof(struct sadb_lifetime)/sizeof(uint64_t);
  681. lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
  682. lifetime->sadb_lifetime_allocations = _X2KEY(x->lft.hard_packet_limit);
  683. lifetime->sadb_lifetime_bytes = _X2KEY(x->lft.hard_byte_limit);
  684. lifetime->sadb_lifetime_addtime = x->lft.hard_add_expires_seconds;
  685. lifetime->sadb_lifetime_usetime = x->lft.hard_use_expires_seconds;
  686. }
  687. /* soft time */
  688. if (hsc & 1) {
  689. lifetime = (struct sadb_lifetime *) skb_put(skb,
  690. sizeof(struct sadb_lifetime));
  691. lifetime->sadb_lifetime_len =
  692. sizeof(struct sadb_lifetime)/sizeof(uint64_t);
  693. lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
  694. lifetime->sadb_lifetime_allocations = _X2KEY(x->lft.soft_packet_limit);
  695. lifetime->sadb_lifetime_bytes = _X2KEY(x->lft.soft_byte_limit);
  696. lifetime->sadb_lifetime_addtime = x->lft.soft_add_expires_seconds;
  697. lifetime->sadb_lifetime_usetime = x->lft.soft_use_expires_seconds;
  698. }
  699. /* current time */
  700. lifetime = (struct sadb_lifetime *) skb_put(skb,
  701. sizeof(struct sadb_lifetime));
  702. lifetime->sadb_lifetime_len =
  703. sizeof(struct sadb_lifetime)/sizeof(uint64_t);
  704. lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
  705. lifetime->sadb_lifetime_allocations = x->curlft.packets;
  706. lifetime->sadb_lifetime_bytes = x->curlft.bytes;
  707. lifetime->sadb_lifetime_addtime = x->curlft.add_time;
  708. lifetime->sadb_lifetime_usetime = x->curlft.use_time;
  709. /* src address */
  710. addr = (struct sadb_address*) skb_put(skb,
  711. sizeof(struct sadb_address)+sockaddr_size);
  712. addr->sadb_address_len =
  713. (sizeof(struct sadb_address)+sockaddr_size)/
  714. sizeof(uint64_t);
  715. addr->sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
  716. /* "if the ports are non-zero, then the sadb_address_proto field,
  717. normally zero, MUST be filled in with the transport
  718. protocol's number." - RFC2367 */
  719. addr->sadb_address_proto = 0;
  720. addr->sadb_address_reserved = 0;
  721. if (x->props.family == AF_INET) {
  722. addr->sadb_address_prefixlen = 32;
  723. sin = (struct sockaddr_in *) (addr + 1);
  724. sin->sin_family = AF_INET;
  725. sin->sin_addr.s_addr = x->props.saddr.a4;
  726. sin->sin_port = 0;
  727. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  728. }
  729. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  730. else if (x->props.family == AF_INET6) {
  731. addr->sadb_address_prefixlen = 128;
  732. sin6 = (struct sockaddr_in6 *) (addr + 1);
  733. sin6->sin6_family = AF_INET6;
  734. sin6->sin6_port = 0;
  735. sin6->sin6_flowinfo = 0;
  736. memcpy(&sin6->sin6_addr, x->props.saddr.a6,
  737. sizeof(struct in6_addr));
  738. sin6->sin6_scope_id = 0;
  739. }
  740. #endif
  741. else
  742. BUG();
  743. /* dst address */
  744. addr = (struct sadb_address*) skb_put(skb,
  745. sizeof(struct sadb_address)+sockaddr_size);
  746. addr->sadb_address_len =
  747. (sizeof(struct sadb_address)+sockaddr_size)/
  748. sizeof(uint64_t);
  749. addr->sadb_address_exttype = SADB_EXT_ADDRESS_DST;
  750. addr->sadb_address_proto = 0;
  751. addr->sadb_address_prefixlen = 32; /* XXX */
  752. addr->sadb_address_reserved = 0;
  753. if (x->props.family == AF_INET) {
  754. sin = (struct sockaddr_in *) (addr + 1);
  755. sin->sin_family = AF_INET;
  756. sin->sin_addr.s_addr = x->id.daddr.a4;
  757. sin->sin_port = 0;
  758. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  759. if (x->sel.saddr.a4 != x->props.saddr.a4) {
  760. addr = (struct sadb_address*) skb_put(skb,
  761. sizeof(struct sadb_address)+sockaddr_size);
  762. addr->sadb_address_len =
  763. (sizeof(struct sadb_address)+sockaddr_size)/
  764. sizeof(uint64_t);
  765. addr->sadb_address_exttype = SADB_EXT_ADDRESS_PROXY;
  766. addr->sadb_address_proto =
  767. pfkey_proto_from_xfrm(x->sel.proto);
  768. addr->sadb_address_prefixlen = x->sel.prefixlen_s;
  769. addr->sadb_address_reserved = 0;
  770. sin = (struct sockaddr_in *) (addr + 1);
  771. sin->sin_family = AF_INET;
  772. sin->sin_addr.s_addr = x->sel.saddr.a4;
  773. sin->sin_port = x->sel.sport;
  774. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  775. }
  776. }
  777. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  778. else if (x->props.family == AF_INET6) {
  779. addr->sadb_address_prefixlen = 128;
  780. sin6 = (struct sockaddr_in6 *) (addr + 1);
  781. sin6->sin6_family = AF_INET6;
  782. sin6->sin6_port = 0;
  783. sin6->sin6_flowinfo = 0;
  784. memcpy(&sin6->sin6_addr, x->id.daddr.a6, sizeof(struct in6_addr));
  785. sin6->sin6_scope_id = 0;
  786. if (memcmp (x->sel.saddr.a6, x->props.saddr.a6,
  787. sizeof(struct in6_addr))) {
  788. addr = (struct sadb_address *) skb_put(skb,
  789. sizeof(struct sadb_address)+sockaddr_size);
  790. addr->sadb_address_len =
  791. (sizeof(struct sadb_address)+sockaddr_size)/
  792. sizeof(uint64_t);
  793. addr->sadb_address_exttype = SADB_EXT_ADDRESS_PROXY;
  794. addr->sadb_address_proto =
  795. pfkey_proto_from_xfrm(x->sel.proto);
  796. addr->sadb_address_prefixlen = x->sel.prefixlen_s;
  797. addr->sadb_address_reserved = 0;
  798. sin6 = (struct sockaddr_in6 *) (addr + 1);
  799. sin6->sin6_family = AF_INET6;
  800. sin6->sin6_port = x->sel.sport;
  801. sin6->sin6_flowinfo = 0;
  802. memcpy(&sin6->sin6_addr, x->sel.saddr.a6,
  803. sizeof(struct in6_addr));
  804. sin6->sin6_scope_id = 0;
  805. }
  806. }
  807. #endif
  808. else
  809. BUG();
  810. /* auth key */
  811. if (add_keys && auth_key_size) {
  812. key = (struct sadb_key *) skb_put(skb,
  813. sizeof(struct sadb_key)+auth_key_size);
  814. key->sadb_key_len = (sizeof(struct sadb_key) + auth_key_size) /
  815. sizeof(uint64_t);
  816. key->sadb_key_exttype = SADB_EXT_KEY_AUTH;
  817. key->sadb_key_bits = x->aalg->alg_key_len;
  818. key->sadb_key_reserved = 0;
  819. memcpy(key + 1, x->aalg->alg_key, (x->aalg->alg_key_len+7)/8);
  820. }
  821. /* encrypt key */
  822. if (add_keys && encrypt_key_size) {
  823. key = (struct sadb_key *) skb_put(skb,
  824. sizeof(struct sadb_key)+encrypt_key_size);
  825. key->sadb_key_len = (sizeof(struct sadb_key) +
  826. encrypt_key_size) / sizeof(uint64_t);
  827. key->sadb_key_exttype = SADB_EXT_KEY_ENCRYPT;
  828. key->sadb_key_bits = x->ealg->alg_key_len;
  829. key->sadb_key_reserved = 0;
  830. memcpy(key + 1, x->ealg->alg_key,
  831. (x->ealg->alg_key_len+7)/8);
  832. }
  833. /* sa */
  834. sa2 = (struct sadb_x_sa2 *) skb_put(skb, sizeof(struct sadb_x_sa2));
  835. sa2->sadb_x_sa2_len = sizeof(struct sadb_x_sa2)/sizeof(uint64_t);
  836. sa2->sadb_x_sa2_exttype = SADB_X_EXT_SA2;
  837. if ((mode = pfkey_mode_from_xfrm(x->props.mode)) < 0) {
  838. kfree_skb(skb);
  839. return ERR_PTR(-EINVAL);
  840. }
  841. sa2->sadb_x_sa2_mode = mode;
  842. sa2->sadb_x_sa2_reserved1 = 0;
  843. sa2->sadb_x_sa2_reserved2 = 0;
  844. sa2->sadb_x_sa2_sequence = 0;
  845. sa2->sadb_x_sa2_reqid = x->props.reqid;
  846. if (natt && natt->encap_type) {
  847. struct sadb_x_nat_t_type *n_type;
  848. struct sadb_x_nat_t_port *n_port;
  849. /* type */
  850. n_type = (struct sadb_x_nat_t_type*) skb_put(skb, sizeof(*n_type));
  851. n_type->sadb_x_nat_t_type_len = sizeof(*n_type)/sizeof(uint64_t);
  852. n_type->sadb_x_nat_t_type_exttype = SADB_X_EXT_NAT_T_TYPE;
  853. n_type->sadb_x_nat_t_type_type = natt->encap_type;
  854. n_type->sadb_x_nat_t_type_reserved[0] = 0;
  855. n_type->sadb_x_nat_t_type_reserved[1] = 0;
  856. n_type->sadb_x_nat_t_type_reserved[2] = 0;
  857. /* source port */
  858. n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
  859. n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
  860. n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_SPORT;
  861. n_port->sadb_x_nat_t_port_port = natt->encap_sport;
  862. n_port->sadb_x_nat_t_port_reserved = 0;
  863. /* dest port */
  864. n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
  865. n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
  866. n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_DPORT;
  867. n_port->sadb_x_nat_t_port_port = natt->encap_dport;
  868. n_port->sadb_x_nat_t_port_reserved = 0;
  869. }
  870. /* security context */
  871. if (xfrm_ctx) {
  872. sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb,
  873. sizeof(struct sadb_x_sec_ctx) + ctx_size);
  874. sec_ctx->sadb_x_sec_len =
  875. (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t);
  876. sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
  877. sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi;
  878. sec_ctx->sadb_x_ctx_alg = xfrm_ctx->ctx_alg;
  879. sec_ctx->sadb_x_ctx_len = xfrm_ctx->ctx_len;
  880. memcpy(sec_ctx + 1, xfrm_ctx->ctx_str,
  881. xfrm_ctx->ctx_len);
  882. }
  883. return skb;
  884. }
  885. static struct xfrm_state * pfkey_msg2xfrm_state(struct sadb_msg *hdr,
  886. void **ext_hdrs)
  887. {
  888. struct xfrm_state *x;
  889. struct sadb_lifetime *lifetime;
  890. struct sadb_sa *sa;
  891. struct sadb_key *key;
  892. struct sadb_x_sec_ctx *sec_ctx;
  893. uint16_t proto;
  894. int err;
  895. sa = (struct sadb_sa *) ext_hdrs[SADB_EXT_SA-1];
  896. if (!sa ||
  897. !present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  898. ext_hdrs[SADB_EXT_ADDRESS_DST-1]))
  899. return ERR_PTR(-EINVAL);
  900. if (hdr->sadb_msg_satype == SADB_SATYPE_ESP &&
  901. !ext_hdrs[SADB_EXT_KEY_ENCRYPT-1])
  902. return ERR_PTR(-EINVAL);
  903. if (hdr->sadb_msg_satype == SADB_SATYPE_AH &&
  904. !ext_hdrs[SADB_EXT_KEY_AUTH-1])
  905. return ERR_PTR(-EINVAL);
  906. if (!!ext_hdrs[SADB_EXT_LIFETIME_HARD-1] !=
  907. !!ext_hdrs[SADB_EXT_LIFETIME_SOFT-1])
  908. return ERR_PTR(-EINVAL);
  909. proto = pfkey_satype2proto(hdr->sadb_msg_satype);
  910. if (proto == 0)
  911. return ERR_PTR(-EINVAL);
  912. /* default error is no buffer space */
  913. err = -ENOBUFS;
  914. /* RFC2367:
  915. Only SADB_SASTATE_MATURE SAs may be submitted in an SADB_ADD message.
  916. SADB_SASTATE_LARVAL SAs are created by SADB_GETSPI and it is not
  917. sensible to add a new SA in the DYING or SADB_SASTATE_DEAD state.
  918. Therefore, the sadb_sa_state field of all submitted SAs MUST be
  919. SADB_SASTATE_MATURE and the kernel MUST return an error if this is
  920. not true.
  921. However, KAME setkey always uses SADB_SASTATE_LARVAL.
  922. Hence, we have to _ignore_ sadb_sa_state, which is also reasonable.
  923. */
  924. if (sa->sadb_sa_auth > SADB_AALG_MAX ||
  925. (hdr->sadb_msg_satype == SADB_X_SATYPE_IPCOMP &&
  926. sa->sadb_sa_encrypt > SADB_X_CALG_MAX) ||
  927. sa->sadb_sa_encrypt > SADB_EALG_MAX)
  928. return ERR_PTR(-EINVAL);
  929. key = (struct sadb_key*) ext_hdrs[SADB_EXT_KEY_AUTH-1];
  930. if (key != NULL &&
  931. sa->sadb_sa_auth != SADB_X_AALG_NULL &&
  932. ((key->sadb_key_bits+7) / 8 == 0 ||
  933. (key->sadb_key_bits+7) / 8 > key->sadb_key_len * sizeof(uint64_t)))
  934. return ERR_PTR(-EINVAL);
  935. key = ext_hdrs[SADB_EXT_KEY_ENCRYPT-1];
  936. if (key != NULL &&
  937. sa->sadb_sa_encrypt != SADB_EALG_NULL &&
  938. ((key->sadb_key_bits+7) / 8 == 0 ||
  939. (key->sadb_key_bits+7) / 8 > key->sadb_key_len * sizeof(uint64_t)))
  940. return ERR_PTR(-EINVAL);
  941. x = xfrm_state_alloc();
  942. if (x == NULL)
  943. return ERR_PTR(-ENOBUFS);
  944. x->id.proto = proto;
  945. x->id.spi = sa->sadb_sa_spi;
  946. x->props.replay_window = sa->sadb_sa_replay;
  947. if (sa->sadb_sa_flags & SADB_SAFLAGS_NOECN)
  948. x->props.flags |= XFRM_STATE_NOECN;
  949. if (sa->sadb_sa_flags & SADB_SAFLAGS_DECAP_DSCP)
  950. x->props.flags |= XFRM_STATE_DECAP_DSCP;
  951. if (sa->sadb_sa_flags & SADB_SAFLAGS_NOPMTUDISC)
  952. x->props.flags |= XFRM_STATE_NOPMTUDISC;
  953. lifetime = (struct sadb_lifetime*) ext_hdrs[SADB_EXT_LIFETIME_HARD-1];
  954. if (lifetime != NULL) {
  955. x->lft.hard_packet_limit = _KEY2X(lifetime->sadb_lifetime_allocations);
  956. x->lft.hard_byte_limit = _KEY2X(lifetime->sadb_lifetime_bytes);
  957. x->lft.hard_add_expires_seconds = lifetime->sadb_lifetime_addtime;
  958. x->lft.hard_use_expires_seconds = lifetime->sadb_lifetime_usetime;
  959. }
  960. lifetime = (struct sadb_lifetime*) ext_hdrs[SADB_EXT_LIFETIME_SOFT-1];
  961. if (lifetime != NULL) {
  962. x->lft.soft_packet_limit = _KEY2X(lifetime->sadb_lifetime_allocations);
  963. x->lft.soft_byte_limit = _KEY2X(lifetime->sadb_lifetime_bytes);
  964. x->lft.soft_add_expires_seconds = lifetime->sadb_lifetime_addtime;
  965. x->lft.soft_use_expires_seconds = lifetime->sadb_lifetime_usetime;
  966. }
  967. sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1];
  968. if (sec_ctx != NULL) {
  969. struct xfrm_user_sec_ctx *uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx);
  970. if (!uctx)
  971. goto out;
  972. err = security_xfrm_state_alloc(x, uctx);
  973. kfree(uctx);
  974. if (err)
  975. goto out;
  976. }
  977. key = (struct sadb_key*) ext_hdrs[SADB_EXT_KEY_AUTH-1];
  978. if (sa->sadb_sa_auth) {
  979. int keysize = 0;
  980. struct xfrm_algo_desc *a = xfrm_aalg_get_byid(sa->sadb_sa_auth);
  981. if (!a) {
  982. err = -ENOSYS;
  983. goto out;
  984. }
  985. if (key)
  986. keysize = (key->sadb_key_bits + 7) / 8;
  987. x->aalg = kmalloc(sizeof(*x->aalg) + keysize, GFP_KERNEL);
  988. if (!x->aalg)
  989. goto out;
  990. strcpy(x->aalg->alg_name, a->name);
  991. x->aalg->alg_key_len = 0;
  992. if (key) {
  993. x->aalg->alg_key_len = key->sadb_key_bits;
  994. memcpy(x->aalg->alg_key, key+1, keysize);
  995. }
  996. x->props.aalgo = sa->sadb_sa_auth;
  997. /* x->algo.flags = sa->sadb_sa_flags; */
  998. }
  999. if (sa->sadb_sa_encrypt) {
  1000. if (hdr->sadb_msg_satype == SADB_X_SATYPE_IPCOMP) {
  1001. struct xfrm_algo_desc *a = xfrm_calg_get_byid(sa->sadb_sa_encrypt);
  1002. if (!a) {
  1003. err = -ENOSYS;
  1004. goto out;
  1005. }
  1006. x->calg = kmalloc(sizeof(*x->calg), GFP_KERNEL);
  1007. if (!x->calg)
  1008. goto out;
  1009. strcpy(x->calg->alg_name, a->name);
  1010. x->props.calgo = sa->sadb_sa_encrypt;
  1011. } else {
  1012. int keysize = 0;
  1013. struct xfrm_algo_desc *a = xfrm_ealg_get_byid(sa->sadb_sa_encrypt);
  1014. if (!a) {
  1015. err = -ENOSYS;
  1016. goto out;
  1017. }
  1018. key = (struct sadb_key*) ext_hdrs[SADB_EXT_KEY_ENCRYPT-1];
  1019. if (key)
  1020. keysize = (key->sadb_key_bits + 7) / 8;
  1021. x->ealg = kmalloc(sizeof(*x->ealg) + keysize, GFP_KERNEL);
  1022. if (!x->ealg)
  1023. goto out;
  1024. strcpy(x->ealg->alg_name, a->name);
  1025. x->ealg->alg_key_len = 0;
  1026. if (key) {
  1027. x->ealg->alg_key_len = key->sadb_key_bits;
  1028. memcpy(x->ealg->alg_key, key+1, keysize);
  1029. }
  1030. x->props.ealgo = sa->sadb_sa_encrypt;
  1031. }
  1032. }
  1033. /* x->algo.flags = sa->sadb_sa_flags; */
  1034. x->props.family = pfkey_sadb_addr2xfrm_addr((struct sadb_address *) ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1035. &x->props.saddr);
  1036. if (!x->props.family) {
  1037. err = -EAFNOSUPPORT;
  1038. goto out;
  1039. }
  1040. pfkey_sadb_addr2xfrm_addr((struct sadb_address *) ext_hdrs[SADB_EXT_ADDRESS_DST-1],
  1041. &x->id.daddr);
  1042. if (ext_hdrs[SADB_X_EXT_SA2-1]) {
  1043. struct sadb_x_sa2 *sa2 = (void*)ext_hdrs[SADB_X_EXT_SA2-1];
  1044. int mode = pfkey_mode_to_xfrm(sa2->sadb_x_sa2_mode);
  1045. if (mode < 0) {
  1046. err = -EINVAL;
  1047. goto out;
  1048. }
  1049. x->props.mode = mode;
  1050. x->props.reqid = sa2->sadb_x_sa2_reqid;
  1051. }
  1052. if (ext_hdrs[SADB_EXT_ADDRESS_PROXY-1]) {
  1053. struct sadb_address *addr = ext_hdrs[SADB_EXT_ADDRESS_PROXY-1];
  1054. /* Nobody uses this, but we try. */
  1055. x->sel.family = pfkey_sadb_addr2xfrm_addr(addr, &x->sel.saddr);
  1056. x->sel.prefixlen_s = addr->sadb_address_prefixlen;
  1057. }
  1058. if (!x->sel.family)
  1059. x->sel.family = x->props.family;
  1060. if (ext_hdrs[SADB_X_EXT_NAT_T_TYPE-1]) {
  1061. struct sadb_x_nat_t_type* n_type;
  1062. struct xfrm_encap_tmpl *natt;
  1063. x->encap = kmalloc(sizeof(*x->encap), GFP_KERNEL);
  1064. if (!x->encap)
  1065. goto out;
  1066. natt = x->encap;
  1067. n_type = ext_hdrs[SADB_X_EXT_NAT_T_TYPE-1];
  1068. natt->encap_type = n_type->sadb_x_nat_t_type_type;
  1069. if (ext_hdrs[SADB_X_EXT_NAT_T_SPORT-1]) {
  1070. struct sadb_x_nat_t_port* n_port =
  1071. ext_hdrs[SADB_X_EXT_NAT_T_SPORT-1];
  1072. natt->encap_sport = n_port->sadb_x_nat_t_port_port;
  1073. }
  1074. if (ext_hdrs[SADB_X_EXT_NAT_T_DPORT-1]) {
  1075. struct sadb_x_nat_t_port* n_port =
  1076. ext_hdrs[SADB_X_EXT_NAT_T_DPORT-1];
  1077. natt->encap_dport = n_port->sadb_x_nat_t_port_port;
  1078. }
  1079. }
  1080. err = xfrm_init_state(x);
  1081. if (err)
  1082. goto out;
  1083. x->km.seq = hdr->sadb_msg_seq;
  1084. return x;
  1085. out:
  1086. x->km.state = XFRM_STATE_DEAD;
  1087. xfrm_state_put(x);
  1088. return ERR_PTR(err);
  1089. }
  1090. static int pfkey_reserved(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1091. {
  1092. return -EOPNOTSUPP;
  1093. }
  1094. static int pfkey_getspi(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1095. {
  1096. struct sk_buff *resp_skb;
  1097. struct sadb_x_sa2 *sa2;
  1098. struct sadb_address *saddr, *daddr;
  1099. struct sadb_msg *out_hdr;
  1100. struct xfrm_state *x = NULL;
  1101. int mode;
  1102. u32 reqid;
  1103. u8 proto;
  1104. unsigned short family;
  1105. xfrm_address_t *xsaddr = NULL, *xdaddr = NULL;
  1106. if (!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1107. ext_hdrs[SADB_EXT_ADDRESS_DST-1]))
  1108. return -EINVAL;
  1109. proto = pfkey_satype2proto(hdr->sadb_msg_satype);
  1110. if (proto == 0)
  1111. return -EINVAL;
  1112. if ((sa2 = ext_hdrs[SADB_X_EXT_SA2-1]) != NULL) {
  1113. mode = pfkey_mode_to_xfrm(sa2->sadb_x_sa2_mode);
  1114. if (mode < 0)
  1115. return -EINVAL;
  1116. reqid = sa2->sadb_x_sa2_reqid;
  1117. } else {
  1118. mode = 0;
  1119. reqid = 0;
  1120. }
  1121. saddr = ext_hdrs[SADB_EXT_ADDRESS_SRC-1];
  1122. daddr = ext_hdrs[SADB_EXT_ADDRESS_DST-1];
  1123. family = ((struct sockaddr *)(saddr + 1))->sa_family;
  1124. switch (family) {
  1125. case AF_INET:
  1126. xdaddr = (xfrm_address_t *)&((struct sockaddr_in *)(daddr + 1))->sin_addr.s_addr;
  1127. xsaddr = (xfrm_address_t *)&((struct sockaddr_in *)(saddr + 1))->sin_addr.s_addr;
  1128. break;
  1129. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1130. case AF_INET6:
  1131. xdaddr = (xfrm_address_t *)&((struct sockaddr_in6 *)(daddr + 1))->sin6_addr;
  1132. xsaddr = (xfrm_address_t *)&((struct sockaddr_in6 *)(saddr + 1))->sin6_addr;
  1133. break;
  1134. #endif
  1135. }
  1136. if (hdr->sadb_msg_seq) {
  1137. x = xfrm_find_acq_byseq(hdr->sadb_msg_seq);
  1138. if (x && xfrm_addr_cmp(&x->id.daddr, xdaddr, family)) {
  1139. xfrm_state_put(x);
  1140. x = NULL;
  1141. }
  1142. }
  1143. if (!x)
  1144. x = xfrm_find_acq(mode, reqid, proto, xdaddr, xsaddr, 1, family);
  1145. if (x == NULL)
  1146. return -ENOENT;
  1147. resp_skb = ERR_PTR(-ENOENT);
  1148. spin_lock_bh(&x->lock);
  1149. if (x->km.state != XFRM_STATE_DEAD) {
  1150. struct sadb_spirange *range = ext_hdrs[SADB_EXT_SPIRANGE-1];
  1151. u32 min_spi, max_spi;
  1152. if (range != NULL) {
  1153. min_spi = range->sadb_spirange_min;
  1154. max_spi = range->sadb_spirange_max;
  1155. } else {
  1156. min_spi = 0x100;
  1157. max_spi = 0x0fffffff;
  1158. }
  1159. xfrm_alloc_spi(x, htonl(min_spi), htonl(max_spi));
  1160. if (x->id.spi)
  1161. resp_skb = pfkey_xfrm_state2msg(x, 0, 3);
  1162. }
  1163. spin_unlock_bh(&x->lock);
  1164. if (IS_ERR(resp_skb)) {
  1165. xfrm_state_put(x);
  1166. return PTR_ERR(resp_skb);
  1167. }
  1168. out_hdr = (struct sadb_msg *) resp_skb->data;
  1169. out_hdr->sadb_msg_version = hdr->sadb_msg_version;
  1170. out_hdr->sadb_msg_type = SADB_GETSPI;
  1171. out_hdr->sadb_msg_satype = pfkey_proto2satype(proto);
  1172. out_hdr->sadb_msg_errno = 0;
  1173. out_hdr->sadb_msg_reserved = 0;
  1174. out_hdr->sadb_msg_seq = hdr->sadb_msg_seq;
  1175. out_hdr->sadb_msg_pid = hdr->sadb_msg_pid;
  1176. xfrm_state_put(x);
  1177. pfkey_broadcast(resp_skb, GFP_KERNEL, BROADCAST_ONE, sk);
  1178. return 0;
  1179. }
  1180. static int pfkey_acquire(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1181. {
  1182. struct xfrm_state *x;
  1183. if (hdr->sadb_msg_len != sizeof(struct sadb_msg)/8)
  1184. return -EOPNOTSUPP;
  1185. if (hdr->sadb_msg_seq == 0 || hdr->sadb_msg_errno == 0)
  1186. return 0;
  1187. x = xfrm_find_acq_byseq(hdr->sadb_msg_seq);
  1188. if (x == NULL)
  1189. return 0;
  1190. spin_lock_bh(&x->lock);
  1191. if (x->km.state == XFRM_STATE_ACQ) {
  1192. x->km.state = XFRM_STATE_ERROR;
  1193. wake_up(&km_waitq);
  1194. }
  1195. spin_unlock_bh(&x->lock);
  1196. xfrm_state_put(x);
  1197. return 0;
  1198. }
  1199. static inline int event2poltype(int event)
  1200. {
  1201. switch (event) {
  1202. case XFRM_MSG_DELPOLICY:
  1203. return SADB_X_SPDDELETE;
  1204. case XFRM_MSG_NEWPOLICY:
  1205. return SADB_X_SPDADD;
  1206. case XFRM_MSG_UPDPOLICY:
  1207. return SADB_X_SPDUPDATE;
  1208. case XFRM_MSG_POLEXPIRE:
  1209. // return SADB_X_SPDEXPIRE;
  1210. default:
  1211. printk("pfkey: Unknown policy event %d\n", event);
  1212. break;
  1213. }
  1214. return 0;
  1215. }
  1216. static inline int event2keytype(int event)
  1217. {
  1218. switch (event) {
  1219. case XFRM_MSG_DELSA:
  1220. return SADB_DELETE;
  1221. case XFRM_MSG_NEWSA:
  1222. return SADB_ADD;
  1223. case XFRM_MSG_UPDSA:
  1224. return SADB_UPDATE;
  1225. case XFRM_MSG_EXPIRE:
  1226. return SADB_EXPIRE;
  1227. default:
  1228. printk("pfkey: Unknown SA event %d\n", event);
  1229. break;
  1230. }
  1231. return 0;
  1232. }
  1233. /* ADD/UPD/DEL */
  1234. static int key_notify_sa(struct xfrm_state *x, struct km_event *c)
  1235. {
  1236. struct sk_buff *skb;
  1237. struct sadb_msg *hdr;
  1238. int hsc = 3;
  1239. if (c->event == XFRM_MSG_DELSA)
  1240. hsc = 0;
  1241. skb = pfkey_xfrm_state2msg(x, 0, hsc);
  1242. if (IS_ERR(skb))
  1243. return PTR_ERR(skb);
  1244. hdr = (struct sadb_msg *) skb->data;
  1245. hdr->sadb_msg_version = PF_KEY_V2;
  1246. hdr->sadb_msg_type = event2keytype(c->event);
  1247. hdr->sadb_msg_satype = pfkey_proto2satype(x->id.proto);
  1248. hdr->sadb_msg_errno = 0;
  1249. hdr->sadb_msg_reserved = 0;
  1250. hdr->sadb_msg_seq = c->seq;
  1251. hdr->sadb_msg_pid = c->pid;
  1252. pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ALL, NULL);
  1253. return 0;
  1254. }
  1255. static int pfkey_add(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1256. {
  1257. struct xfrm_state *x;
  1258. int err;
  1259. struct km_event c;
  1260. x = pfkey_msg2xfrm_state(hdr, ext_hdrs);
  1261. if (IS_ERR(x))
  1262. return PTR_ERR(x);
  1263. xfrm_state_hold(x);
  1264. if (hdr->sadb_msg_type == SADB_ADD)
  1265. err = xfrm_state_add(x);
  1266. else
  1267. err = xfrm_state_update(x);
  1268. xfrm_audit_state_add(x, err ? 0 : 1,
  1269. audit_get_loginuid(current->audit_context), 0);
  1270. if (err < 0) {
  1271. x->km.state = XFRM_STATE_DEAD;
  1272. __xfrm_state_put(x);
  1273. goto out;
  1274. }
  1275. if (hdr->sadb_msg_type == SADB_ADD)
  1276. c.event = XFRM_MSG_NEWSA;
  1277. else
  1278. c.event = XFRM_MSG_UPDSA;
  1279. c.seq = hdr->sadb_msg_seq;
  1280. c.pid = hdr->sadb_msg_pid;
  1281. km_state_notify(x, &c);
  1282. out:
  1283. xfrm_state_put(x);
  1284. return err;
  1285. }
  1286. static int pfkey_delete(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1287. {
  1288. struct xfrm_state *x;
  1289. struct km_event c;
  1290. int err;
  1291. if (!ext_hdrs[SADB_EXT_SA-1] ||
  1292. !present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1293. ext_hdrs[SADB_EXT_ADDRESS_DST-1]))
  1294. return -EINVAL;
  1295. x = pfkey_xfrm_state_lookup(hdr, ext_hdrs);
  1296. if (x == NULL)
  1297. return -ESRCH;
  1298. if ((err = security_xfrm_state_delete(x)))
  1299. goto out;
  1300. if (xfrm_state_kern(x)) {
  1301. err = -EPERM;
  1302. goto out;
  1303. }
  1304. err = xfrm_state_delete(x);
  1305. if (err < 0)
  1306. goto out;
  1307. c.seq = hdr->sadb_msg_seq;
  1308. c.pid = hdr->sadb_msg_pid;
  1309. c.event = XFRM_MSG_DELSA;
  1310. km_state_notify(x, &c);
  1311. out:
  1312. xfrm_audit_state_delete(x, err ? 0 : 1,
  1313. audit_get_loginuid(current->audit_context), 0);
  1314. xfrm_state_put(x);
  1315. return err;
  1316. }
  1317. static int pfkey_get(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1318. {
  1319. __u8 proto;
  1320. struct sk_buff *out_skb;
  1321. struct sadb_msg *out_hdr;
  1322. struct xfrm_state *x;
  1323. if (!ext_hdrs[SADB_EXT_SA-1] ||
  1324. !present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1325. ext_hdrs[SADB_EXT_ADDRESS_DST-1]))
  1326. return -EINVAL;
  1327. x = pfkey_xfrm_state_lookup(hdr, ext_hdrs);
  1328. if (x == NULL)
  1329. return -ESRCH;
  1330. out_skb = pfkey_xfrm_state2msg(x, 1, 3);
  1331. proto = x->id.proto;
  1332. xfrm_state_put(x);
  1333. if (IS_ERR(out_skb))
  1334. return PTR_ERR(out_skb);
  1335. out_hdr = (struct sadb_msg *) out_skb->data;
  1336. out_hdr->sadb_msg_version = hdr->sadb_msg_version;
  1337. out_hdr->sadb_msg_type = SADB_DUMP;
  1338. out_hdr->sadb_msg_satype = pfkey_proto2satype(proto);
  1339. out_hdr->sadb_msg_errno = 0;
  1340. out_hdr->sadb_msg_reserved = 0;
  1341. out_hdr->sadb_msg_seq = hdr->sadb_msg_seq;
  1342. out_hdr->sadb_msg_pid = hdr->sadb_msg_pid;
  1343. pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, sk);
  1344. return 0;
  1345. }
  1346. static struct sk_buff *compose_sadb_supported(struct sadb_msg *orig,
  1347. gfp_t allocation)
  1348. {
  1349. struct sk_buff *skb;
  1350. struct sadb_msg *hdr;
  1351. int len, auth_len, enc_len, i;
  1352. auth_len = xfrm_count_auth_supported();
  1353. if (auth_len) {
  1354. auth_len *= sizeof(struct sadb_alg);
  1355. auth_len += sizeof(struct sadb_supported);
  1356. }
  1357. enc_len = xfrm_count_enc_supported();
  1358. if (enc_len) {
  1359. enc_len *= sizeof(struct sadb_alg);
  1360. enc_len += sizeof(struct sadb_supported);
  1361. }
  1362. len = enc_len + auth_len + sizeof(struct sadb_msg);
  1363. skb = alloc_skb(len + 16, allocation);
  1364. if (!skb)
  1365. goto out_put_algs;
  1366. hdr = (struct sadb_msg *) skb_put(skb, sizeof(*hdr));
  1367. pfkey_hdr_dup(hdr, orig);
  1368. hdr->sadb_msg_errno = 0;
  1369. hdr->sadb_msg_len = len / sizeof(uint64_t);
  1370. if (auth_len) {
  1371. struct sadb_supported *sp;
  1372. struct sadb_alg *ap;
  1373. sp = (struct sadb_supported *) skb_put(skb, auth_len);
  1374. ap = (struct sadb_alg *) (sp + 1);
  1375. sp->sadb_supported_len = auth_len / sizeof(uint64_t);
  1376. sp->sadb_supported_exttype = SADB_EXT_SUPPORTED_AUTH;
  1377. for (i = 0; ; i++) {
  1378. struct xfrm_algo_desc *aalg = xfrm_aalg_get_byidx(i);
  1379. if (!aalg)
  1380. break;
  1381. if (aalg->available)
  1382. *ap++ = aalg->desc;
  1383. }
  1384. }
  1385. if (enc_len) {
  1386. struct sadb_supported *sp;
  1387. struct sadb_alg *ap;
  1388. sp = (struct sadb_supported *) skb_put(skb, enc_len);
  1389. ap = (struct sadb_alg *) (sp + 1);
  1390. sp->sadb_supported_len = enc_len / sizeof(uint64_t);
  1391. sp->sadb_supported_exttype = SADB_EXT_SUPPORTED_ENCRYPT;
  1392. for (i = 0; ; i++) {
  1393. struct xfrm_algo_desc *ealg = xfrm_ealg_get_byidx(i);
  1394. if (!ealg)
  1395. break;
  1396. if (ealg->available)
  1397. *ap++ = ealg->desc;
  1398. }
  1399. }
  1400. out_put_algs:
  1401. return skb;
  1402. }
  1403. static int pfkey_register(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1404. {
  1405. struct pfkey_sock *pfk = pfkey_sk(sk);
  1406. struct sk_buff *supp_skb;
  1407. if (hdr->sadb_msg_satype > SADB_SATYPE_MAX)
  1408. return -EINVAL;
  1409. if (hdr->sadb_msg_satype != SADB_SATYPE_UNSPEC) {
  1410. if (pfk->registered&(1<<hdr->sadb_msg_satype))
  1411. return -EEXIST;
  1412. pfk->registered |= (1<<hdr->sadb_msg_satype);
  1413. }
  1414. xfrm_probe_algs();
  1415. supp_skb = compose_sadb_supported(hdr, GFP_KERNEL);
  1416. if (!supp_skb) {
  1417. if (hdr->sadb_msg_satype != SADB_SATYPE_UNSPEC)
  1418. pfk->registered &= ~(1<<hdr->sadb_msg_satype);
  1419. return -ENOBUFS;
  1420. }
  1421. pfkey_broadcast(supp_skb, GFP_KERNEL, BROADCAST_REGISTERED, sk);
  1422. return 0;
  1423. }
  1424. static int key_notify_sa_flush(struct km_event *c)
  1425. {
  1426. struct sk_buff *skb;
  1427. struct sadb_msg *hdr;
  1428. skb = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
  1429. if (!skb)
  1430. return -ENOBUFS;
  1431. hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
  1432. hdr->sadb_msg_satype = pfkey_proto2satype(c->data.proto);
  1433. hdr->sadb_msg_type = SADB_FLUSH;
  1434. hdr->sadb_msg_seq = c->seq;
  1435. hdr->sadb_msg_pid = c->pid;
  1436. hdr->sadb_msg_version = PF_KEY_V2;
  1437. hdr->sadb_msg_errno = (uint8_t) 0;
  1438. hdr->sadb_msg_len = (sizeof(struct sadb_msg) / sizeof(uint64_t));
  1439. pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ALL, NULL);
  1440. return 0;
  1441. }
  1442. static int pfkey_flush(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1443. {
  1444. unsigned proto;
  1445. struct km_event c;
  1446. struct xfrm_audit audit_info;
  1447. int err;
  1448. proto = pfkey_satype2proto(hdr->sadb_msg_satype);
  1449. if (proto == 0)
  1450. return -EINVAL;
  1451. audit_info.loginuid = audit_get_loginuid(current->audit_context);
  1452. audit_info.secid = 0;
  1453. err = xfrm_state_flush(proto, &audit_info);
  1454. if (err)
  1455. return err;
  1456. c.data.proto = proto;
  1457. c.seq = hdr->sadb_msg_seq;
  1458. c.pid = hdr->sadb_msg_pid;
  1459. c.event = XFRM_MSG_FLUSHSA;
  1460. km_state_notify(NULL, &c);
  1461. return 0;
  1462. }
  1463. struct pfkey_dump_data
  1464. {
  1465. struct sk_buff *skb;
  1466. struct sadb_msg *hdr;
  1467. struct sock *sk;
  1468. };
  1469. static int dump_sa(struct xfrm_state *x, int count, void *ptr)
  1470. {
  1471. struct pfkey_dump_data *data = ptr;
  1472. struct sk_buff *out_skb;
  1473. struct sadb_msg *out_hdr;
  1474. out_skb = pfkey_xfrm_state2msg(x, 1, 3);
  1475. if (IS_ERR(out_skb))
  1476. return PTR_ERR(out_skb);
  1477. out_hdr = (struct sadb_msg *) out_skb->data;
  1478. out_hdr->sadb_msg_version = data->hdr->sadb_msg_version;
  1479. out_hdr->sadb_msg_type = SADB_DUMP;
  1480. out_hdr->sadb_msg_satype = pfkey_proto2satype(x->id.proto);
  1481. out_hdr->sadb_msg_errno = 0;
  1482. out_hdr->sadb_msg_reserved = 0;
  1483. out_hdr->sadb_msg_seq = count;
  1484. out_hdr->sadb_msg_pid = data->hdr->sadb_msg_pid;
  1485. pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, data->sk);
  1486. return 0;
  1487. }
  1488. static int pfkey_dump(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1489. {
  1490. u8 proto;
  1491. struct pfkey_dump_data data = { .skb = skb, .hdr = hdr, .sk = sk };
  1492. proto = pfkey_satype2proto(hdr->sadb_msg_satype);
  1493. if (proto == 0)
  1494. return -EINVAL;
  1495. return xfrm_state_walk(proto, dump_sa, &data);
  1496. }
  1497. static int pfkey_promisc(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1498. {
  1499. struct pfkey_sock *pfk = pfkey_sk(sk);
  1500. int satype = hdr->sadb_msg_satype;
  1501. if (hdr->sadb_msg_len == (sizeof(*hdr) / sizeof(uint64_t))) {
  1502. /* XXX we mangle packet... */
  1503. hdr->sadb_msg_errno = 0;
  1504. if (satype != 0 && satype != 1)
  1505. return -EINVAL;
  1506. pfk->promisc = satype;
  1507. }
  1508. pfkey_broadcast(skb_clone(skb, GFP_KERNEL), GFP_KERNEL, BROADCAST_ALL, NULL);
  1509. return 0;
  1510. }
  1511. static int check_reqid(struct xfrm_policy *xp, int dir, int count, void *ptr)
  1512. {
  1513. int i;
  1514. u32 reqid = *(u32*)ptr;
  1515. for (i=0; i<xp->xfrm_nr; i++) {
  1516. if (xp->xfrm_vec[i].reqid == reqid)
  1517. return -EEXIST;
  1518. }
  1519. return 0;
  1520. }
  1521. static u32 gen_reqid(void)
  1522. {
  1523. u32 start;
  1524. static u32 reqid = IPSEC_MANUAL_REQID_MAX;
  1525. start = reqid;
  1526. do {
  1527. ++reqid;
  1528. if (reqid == 0)
  1529. reqid = IPSEC_MANUAL_REQID_MAX+1;
  1530. if (xfrm_policy_walk(XFRM_POLICY_TYPE_MAIN, check_reqid,
  1531. (void*)&reqid) != -EEXIST)
  1532. return reqid;
  1533. } while (reqid != start);
  1534. return 0;
  1535. }
  1536. static int
  1537. parse_ipsecrequest(struct xfrm_policy *xp, struct sadb_x_ipsecrequest *rq)
  1538. {
  1539. struct xfrm_tmpl *t = xp->xfrm_vec + xp->xfrm_nr;
  1540. struct sockaddr_in *sin;
  1541. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1542. struct sockaddr_in6 *sin6;
  1543. #endif
  1544. int mode;
  1545. if (xp->xfrm_nr >= XFRM_MAX_DEPTH)
  1546. return -ELOOP;
  1547. if (rq->sadb_x_ipsecrequest_mode == 0)
  1548. return -EINVAL;
  1549. t->id.proto = rq->sadb_x_ipsecrequest_proto; /* XXX check proto */
  1550. if ((mode = pfkey_mode_to_xfrm(rq->sadb_x_ipsecrequest_mode)) < 0)
  1551. return -EINVAL;
  1552. t->mode = mode;
  1553. if (rq->sadb_x_ipsecrequest_level == IPSEC_LEVEL_USE)
  1554. t->optional = 1;
  1555. else if (rq->sadb_x_ipsecrequest_level == IPSEC_LEVEL_UNIQUE) {
  1556. t->reqid = rq->sadb_x_ipsecrequest_reqid;
  1557. if (t->reqid > IPSEC_MANUAL_REQID_MAX)
  1558. t->reqid = 0;
  1559. if (!t->reqid && !(t->reqid = gen_reqid()))
  1560. return -ENOBUFS;
  1561. }
  1562. /* addresses present only in tunnel mode */
  1563. if (t->mode == XFRM_MODE_TUNNEL) {
  1564. struct sockaddr *sa;
  1565. sa = (struct sockaddr *)(rq+1);
  1566. switch(sa->sa_family) {
  1567. case AF_INET:
  1568. sin = (struct sockaddr_in*)sa;
  1569. t->saddr.a4 = sin->sin_addr.s_addr;
  1570. sin++;
  1571. if (sin->sin_family != AF_INET)
  1572. return -EINVAL;
  1573. t->id.daddr.a4 = sin->sin_addr.s_addr;
  1574. break;
  1575. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1576. case AF_INET6:
  1577. sin6 = (struct sockaddr_in6*)sa;
  1578. memcpy(t->saddr.a6, &sin6->sin6_addr, sizeof(struct in6_addr));
  1579. sin6++;
  1580. if (sin6->sin6_family != AF_INET6)
  1581. return -EINVAL;
  1582. memcpy(t->id.daddr.a6, &sin6->sin6_addr, sizeof(struct in6_addr));
  1583. break;
  1584. #endif
  1585. default:
  1586. return -EINVAL;
  1587. }
  1588. t->encap_family = sa->sa_family;
  1589. } else
  1590. t->encap_family = xp->family;
  1591. /* No way to set this via kame pfkey */
  1592. t->aalgos = t->ealgos = t->calgos = ~0;
  1593. xp->xfrm_nr++;
  1594. return 0;
  1595. }
  1596. static int
  1597. parse_ipsecrequests(struct xfrm_policy *xp, struct sadb_x_policy *pol)
  1598. {
  1599. int err;
  1600. int len = pol->sadb_x_policy_len*8 - sizeof(struct sadb_x_policy);
  1601. struct sadb_x_ipsecrequest *rq = (void*)(pol+1);
  1602. while (len >= sizeof(struct sadb_x_ipsecrequest)) {
  1603. if ((err = parse_ipsecrequest(xp, rq)) < 0)
  1604. return err;
  1605. len -= rq->sadb_x_ipsecrequest_len;
  1606. rq = (void*)((u8*)rq + rq->sadb_x_ipsecrequest_len);
  1607. }
  1608. return 0;
  1609. }
  1610. static inline int pfkey_xfrm_policy2sec_ctx_size(struct xfrm_policy *xp)
  1611. {
  1612. struct xfrm_sec_ctx *xfrm_ctx = xp->security;
  1613. if (xfrm_ctx) {
  1614. int len = sizeof(struct sadb_x_sec_ctx);
  1615. len += xfrm_ctx->ctx_len;
  1616. return PFKEY_ALIGN8(len);
  1617. }
  1618. return 0;
  1619. }
  1620. static int pfkey_xfrm_policy2msg_size(struct xfrm_policy *xp)
  1621. {
  1622. struct xfrm_tmpl *t;
  1623. int sockaddr_size = pfkey_sockaddr_size(xp->family);
  1624. int socklen = 0;
  1625. int i;
  1626. for (i=0; i<xp->xfrm_nr; i++) {
  1627. t = xp->xfrm_vec + i;
  1628. socklen += (t->encap_family == AF_INET ?
  1629. sizeof(struct sockaddr_in) :
  1630. sizeof(struct sockaddr_in6));
  1631. }
  1632. return sizeof(struct sadb_msg) +
  1633. (sizeof(struct sadb_lifetime) * 3) +
  1634. (sizeof(struct sadb_address) * 2) +
  1635. (sockaddr_size * 2) +
  1636. sizeof(struct sadb_x_policy) +
  1637. (xp->xfrm_nr * sizeof(struct sadb_x_ipsecrequest)) +
  1638. (socklen * 2) +
  1639. pfkey_xfrm_policy2sec_ctx_size(xp);
  1640. }
  1641. static struct sk_buff * pfkey_xfrm_policy2msg_prep(struct xfrm_policy *xp)
  1642. {
  1643. struct sk_buff *skb;
  1644. int size;
  1645. size = pfkey_xfrm_policy2msg_size(xp);
  1646. skb = alloc_skb(size + 16, GFP_ATOMIC);
  1647. if (skb == NULL)
  1648. return ERR_PTR(-ENOBUFS);
  1649. return skb;
  1650. }
  1651. static int pfkey_xfrm_policy2msg(struct sk_buff *skb, struct xfrm_policy *xp, int dir)
  1652. {
  1653. struct sadb_msg *hdr;
  1654. struct sadb_address *addr;
  1655. struct sadb_lifetime *lifetime;
  1656. struct sadb_x_policy *pol;
  1657. struct sockaddr_in *sin;
  1658. struct sadb_x_sec_ctx *sec_ctx;
  1659. struct xfrm_sec_ctx *xfrm_ctx;
  1660. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1661. struct sockaddr_in6 *sin6;
  1662. #endif
  1663. int i;
  1664. int size;
  1665. int sockaddr_size = pfkey_sockaddr_size(xp->family);
  1666. int socklen = (xp->family == AF_INET ?
  1667. sizeof(struct sockaddr_in) :
  1668. sizeof(struct sockaddr_in6));
  1669. size = pfkey_xfrm_policy2msg_size(xp);
  1670. /* call should fill header later */
  1671. hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
  1672. memset(hdr, 0, size); /* XXX do we need this ? */
  1673. /* src address */
  1674. addr = (struct sadb_address*) skb_put(skb,
  1675. sizeof(struct sadb_address)+sockaddr_size);
  1676. addr->sadb_address_len =
  1677. (sizeof(struct sadb_address)+sockaddr_size)/
  1678. sizeof(uint64_t);
  1679. addr->sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
  1680. addr->sadb_address_proto = pfkey_proto_from_xfrm(xp->selector.proto);
  1681. addr->sadb_address_prefixlen = xp->selector.prefixlen_s;
  1682. addr->sadb_address_reserved = 0;
  1683. /* src address */
  1684. if (xp->family == AF_INET) {
  1685. sin = (struct sockaddr_in *) (addr + 1);
  1686. sin->sin_family = AF_INET;
  1687. sin->sin_addr.s_addr = xp->selector.saddr.a4;
  1688. sin->sin_port = xp->selector.sport;
  1689. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  1690. }
  1691. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1692. else if (xp->family == AF_INET6) {
  1693. sin6 = (struct sockaddr_in6 *) (addr + 1);
  1694. sin6->sin6_family = AF_INET6;
  1695. sin6->sin6_port = xp->selector.sport;
  1696. sin6->sin6_flowinfo = 0;
  1697. memcpy(&sin6->sin6_addr, xp->selector.saddr.a6,
  1698. sizeof(struct in6_addr));
  1699. sin6->sin6_scope_id = 0;
  1700. }
  1701. #endif
  1702. else
  1703. BUG();
  1704. /* dst address */
  1705. addr = (struct sadb_address*) skb_put(skb,
  1706. sizeof(struct sadb_address)+sockaddr_size);
  1707. addr->sadb_address_len =
  1708. (sizeof(struct sadb_address)+sockaddr_size)/
  1709. sizeof(uint64_t);
  1710. addr->sadb_address_exttype = SADB_EXT_ADDRESS_DST;
  1711. addr->sadb_address_proto = pfkey_proto_from_xfrm(xp->selector.proto);
  1712. addr->sadb_address_prefixlen = xp->selector.prefixlen_d;
  1713. addr->sadb_address_reserved = 0;
  1714. if (xp->family == AF_INET) {
  1715. sin = (struct sockaddr_in *) (addr + 1);
  1716. sin->sin_family = AF_INET;
  1717. sin->sin_addr.s_addr = xp->selector.daddr.a4;
  1718. sin->sin_port = xp->selector.dport;
  1719. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  1720. }
  1721. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1722. else if (xp->family == AF_INET6) {
  1723. sin6 = (struct sockaddr_in6 *) (addr + 1);
  1724. sin6->sin6_family = AF_INET6;
  1725. sin6->sin6_port = xp->selector.dport;
  1726. sin6->sin6_flowinfo = 0;
  1727. memcpy(&sin6->sin6_addr, xp->selector.daddr.a6,
  1728. sizeof(struct in6_addr));
  1729. sin6->sin6_scope_id = 0;
  1730. }
  1731. #endif
  1732. else
  1733. BUG();
  1734. /* hard time */
  1735. lifetime = (struct sadb_lifetime *) skb_put(skb,
  1736. sizeof(struct sadb_lifetime));
  1737. lifetime->sadb_lifetime_len =
  1738. sizeof(struct sadb_lifetime)/sizeof(uint64_t);
  1739. lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_HARD;
  1740. lifetime->sadb_lifetime_allocations = _X2KEY(xp->lft.hard_packet_limit);
  1741. lifetime->sadb_lifetime_bytes = _X2KEY(xp->lft.hard_byte_limit);
  1742. lifetime->sadb_lifetime_addtime = xp->lft.hard_add_expires_seconds;
  1743. lifetime->sadb_lifetime_usetime = xp->lft.hard_use_expires_seconds;
  1744. /* soft time */
  1745. lifetime = (struct sadb_lifetime *) skb_put(skb,
  1746. sizeof(struct sadb_lifetime));
  1747. lifetime->sadb_lifetime_len =
  1748. sizeof(struct sadb_lifetime)/sizeof(uint64_t);
  1749. lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_SOFT;
  1750. lifetime->sadb_lifetime_allocations = _X2KEY(xp->lft.soft_packet_limit);
  1751. lifetime->sadb_lifetime_bytes = _X2KEY(xp->lft.soft_byte_limit);
  1752. lifetime->sadb_lifetime_addtime = xp->lft.soft_add_expires_seconds;
  1753. lifetime->sadb_lifetime_usetime = xp->lft.soft_use_expires_seconds;
  1754. /* current time */
  1755. lifetime = (struct sadb_lifetime *) skb_put(skb,
  1756. sizeof(struct sadb_lifetime));
  1757. lifetime->sadb_lifetime_len =
  1758. sizeof(struct sadb_lifetime)/sizeof(uint64_t);
  1759. lifetime->sadb_lifetime_exttype = SADB_EXT_LIFETIME_CURRENT;
  1760. lifetime->sadb_lifetime_allocations = xp->curlft.packets;
  1761. lifetime->sadb_lifetime_bytes = xp->curlft.bytes;
  1762. lifetime->sadb_lifetime_addtime = xp->curlft.add_time;
  1763. lifetime->sadb_lifetime_usetime = xp->curlft.use_time;
  1764. pol = (struct sadb_x_policy *) skb_put(skb, sizeof(struct sadb_x_policy));
  1765. pol->sadb_x_policy_len = sizeof(struct sadb_x_policy)/sizeof(uint64_t);
  1766. pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
  1767. pol->sadb_x_policy_type = IPSEC_POLICY_DISCARD;
  1768. if (xp->action == XFRM_POLICY_ALLOW) {
  1769. if (xp->xfrm_nr)
  1770. pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;
  1771. else
  1772. pol->sadb_x_policy_type = IPSEC_POLICY_NONE;
  1773. }
  1774. pol->sadb_x_policy_dir = dir+1;
  1775. pol->sadb_x_policy_id = xp->index;
  1776. pol->sadb_x_policy_priority = xp->priority;
  1777. for (i=0; i<xp->xfrm_nr; i++) {
  1778. struct sadb_x_ipsecrequest *rq;
  1779. struct xfrm_tmpl *t = xp->xfrm_vec + i;
  1780. int req_size;
  1781. int mode;
  1782. req_size = sizeof(struct sadb_x_ipsecrequest);
  1783. if (t->mode == XFRM_MODE_TUNNEL)
  1784. req_size += ((t->encap_family == AF_INET ?
  1785. sizeof(struct sockaddr_in) :
  1786. sizeof(struct sockaddr_in6)) * 2);
  1787. else
  1788. size -= 2*socklen;
  1789. rq = (void*)skb_put(skb, req_size);
  1790. pol->sadb_x_policy_len += req_size/8;
  1791. memset(rq, 0, sizeof(*rq));
  1792. rq->sadb_x_ipsecrequest_len = req_size;
  1793. rq->sadb_x_ipsecrequest_proto = t->id.proto;
  1794. if ((mode = pfkey_mode_from_xfrm(t->mode)) < 0)
  1795. return -EINVAL;
  1796. rq->sadb_x_ipsecrequest_mode = mode;
  1797. rq->sadb_x_ipsecrequest_level = IPSEC_LEVEL_REQUIRE;
  1798. if (t->reqid)
  1799. rq->sadb_x_ipsecrequest_level = IPSEC_LEVEL_UNIQUE;
  1800. if (t->optional)
  1801. rq->sadb_x_ipsecrequest_level = IPSEC_LEVEL_USE;
  1802. rq->sadb_x_ipsecrequest_reqid = t->reqid;
  1803. if (t->mode == XFRM_MODE_TUNNEL) {
  1804. switch (t->encap_family) {
  1805. case AF_INET:
  1806. sin = (void*)(rq+1);
  1807. sin->sin_family = AF_INET;
  1808. sin->sin_addr.s_addr = t->saddr.a4;
  1809. sin->sin_port = 0;
  1810. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  1811. sin++;
  1812. sin->sin_family = AF_INET;
  1813. sin->sin_addr.s_addr = t->id.daddr.a4;
  1814. sin->sin_port = 0;
  1815. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  1816. break;
  1817. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  1818. case AF_INET6:
  1819. sin6 = (void*)(rq+1);
  1820. sin6->sin6_family = AF_INET6;
  1821. sin6->sin6_port = 0;
  1822. sin6->sin6_flowinfo = 0;
  1823. memcpy(&sin6->sin6_addr, t->saddr.a6,
  1824. sizeof(struct in6_addr));
  1825. sin6->sin6_scope_id = 0;
  1826. sin6++;
  1827. sin6->sin6_family = AF_INET6;
  1828. sin6->sin6_port = 0;
  1829. sin6->sin6_flowinfo = 0;
  1830. memcpy(&sin6->sin6_addr, t->id.daddr.a6,
  1831. sizeof(struct in6_addr));
  1832. sin6->sin6_scope_id = 0;
  1833. break;
  1834. #endif
  1835. default:
  1836. break;
  1837. }
  1838. }
  1839. }
  1840. /* security context */
  1841. if ((xfrm_ctx = xp->security)) {
  1842. int ctx_size = pfkey_xfrm_policy2sec_ctx_size(xp);
  1843. sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb, ctx_size);
  1844. sec_ctx->sadb_x_sec_len = ctx_size / sizeof(uint64_t);
  1845. sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
  1846. sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi;
  1847. sec_ctx->sadb_x_ctx_alg = xfrm_ctx->ctx_alg;
  1848. sec_ctx->sadb_x_ctx_len = xfrm_ctx->ctx_len;
  1849. memcpy(sec_ctx + 1, xfrm_ctx->ctx_str,
  1850. xfrm_ctx->ctx_len);
  1851. }
  1852. hdr->sadb_msg_len = size / sizeof(uint64_t);
  1853. hdr->sadb_msg_reserved = atomic_read(&xp->refcnt);
  1854. return 0;
  1855. }
  1856. static int key_notify_policy(struct xfrm_policy *xp, int dir, struct km_event *c)
  1857. {
  1858. struct sk_buff *out_skb;
  1859. struct sadb_msg *out_hdr;
  1860. int err;
  1861. out_skb = pfkey_xfrm_policy2msg_prep(xp);
  1862. if (IS_ERR(out_skb)) {
  1863. err = PTR_ERR(out_skb);
  1864. goto out;
  1865. }
  1866. err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
  1867. if (err < 0)
  1868. return err;
  1869. out_hdr = (struct sadb_msg *) out_skb->data;
  1870. out_hdr->sadb_msg_version = PF_KEY_V2;
  1871. if (c->data.byid && c->event == XFRM_MSG_DELPOLICY)
  1872. out_hdr->sadb_msg_type = SADB_X_SPDDELETE2;
  1873. else
  1874. out_hdr->sadb_msg_type = event2poltype(c->event);
  1875. out_hdr->sadb_msg_errno = 0;
  1876. out_hdr->sadb_msg_seq = c->seq;
  1877. out_hdr->sadb_msg_pid = c->pid;
  1878. pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ALL, NULL);
  1879. out:
  1880. return 0;
  1881. }
  1882. static int pfkey_spdadd(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1883. {
  1884. int err = 0;
  1885. struct sadb_lifetime *lifetime;
  1886. struct sadb_address *sa;
  1887. struct sadb_x_policy *pol;
  1888. struct xfrm_policy *xp;
  1889. struct km_event c;
  1890. struct sadb_x_sec_ctx *sec_ctx;
  1891. if (!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1892. ext_hdrs[SADB_EXT_ADDRESS_DST-1]) ||
  1893. !ext_hdrs[SADB_X_EXT_POLICY-1])
  1894. return -EINVAL;
  1895. pol = ext_hdrs[SADB_X_EXT_POLICY-1];
  1896. if (pol->sadb_x_policy_type > IPSEC_POLICY_IPSEC)
  1897. return -EINVAL;
  1898. if (!pol->sadb_x_policy_dir || pol->sadb_x_policy_dir >= IPSEC_DIR_MAX)
  1899. return -EINVAL;
  1900. xp = xfrm_policy_alloc(GFP_KERNEL);
  1901. if (xp == NULL)
  1902. return -ENOBUFS;
  1903. xp->action = (pol->sadb_x_policy_type == IPSEC_POLICY_DISCARD ?
  1904. XFRM_POLICY_BLOCK : XFRM_POLICY_ALLOW);
  1905. xp->priority = pol->sadb_x_policy_priority;
  1906. sa = ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1907. xp->family = pfkey_sadb_addr2xfrm_addr(sa, &xp->selector.saddr);
  1908. if (!xp->family) {
  1909. err = -EINVAL;
  1910. goto out;
  1911. }
  1912. xp->selector.family = xp->family;
  1913. xp->selector.prefixlen_s = sa->sadb_address_prefixlen;
  1914. xp->selector.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
  1915. xp->selector.sport = ((struct sockaddr_in *)(sa+1))->sin_port;
  1916. if (xp->selector.sport)
  1917. xp->selector.sport_mask = htons(0xffff);
  1918. sa = ext_hdrs[SADB_EXT_ADDRESS_DST-1],
  1919. pfkey_sadb_addr2xfrm_addr(sa, &xp->selector.daddr);
  1920. xp->selector.prefixlen_d = sa->sadb_address_prefixlen;
  1921. /* Amusing, we set this twice. KAME apps appear to set same value
  1922. * in both addresses.
  1923. */
  1924. xp->selector.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
  1925. xp->selector.dport = ((struct sockaddr_in *)(sa+1))->sin_port;
  1926. if (xp->selector.dport)
  1927. xp->selector.dport_mask = htons(0xffff);
  1928. sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1];
  1929. if (sec_ctx != NULL) {
  1930. struct xfrm_user_sec_ctx *uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx);
  1931. if (!uctx) {
  1932. err = -ENOBUFS;
  1933. goto out;
  1934. }
  1935. err = security_xfrm_policy_alloc(xp, uctx);
  1936. kfree(uctx);
  1937. if (err)
  1938. goto out;
  1939. }
  1940. xp->lft.soft_byte_limit = XFRM_INF;
  1941. xp->lft.hard_byte_limit = XFRM_INF;
  1942. xp->lft.soft_packet_limit = XFRM_INF;
  1943. xp->lft.hard_packet_limit = XFRM_INF;
  1944. if ((lifetime = ext_hdrs[SADB_EXT_LIFETIME_HARD-1]) != NULL) {
  1945. xp->lft.hard_packet_limit = _KEY2X(lifetime->sadb_lifetime_allocations);
  1946. xp->lft.hard_byte_limit = _KEY2X(lifetime->sadb_lifetime_bytes);
  1947. xp->lft.hard_add_expires_seconds = lifetime->sadb_lifetime_addtime;
  1948. xp->lft.hard_use_expires_seconds = lifetime->sadb_lifetime_usetime;
  1949. }
  1950. if ((lifetime = ext_hdrs[SADB_EXT_LIFETIME_SOFT-1]) != NULL) {
  1951. xp->lft.soft_packet_limit = _KEY2X(lifetime->sadb_lifetime_allocations);
  1952. xp->lft.soft_byte_limit = _KEY2X(lifetime->sadb_lifetime_bytes);
  1953. xp->lft.soft_add_expires_seconds = lifetime->sadb_lifetime_addtime;
  1954. xp->lft.soft_use_expires_seconds = lifetime->sadb_lifetime_usetime;
  1955. }
  1956. xp->xfrm_nr = 0;
  1957. if (pol->sadb_x_policy_type == IPSEC_POLICY_IPSEC &&
  1958. (err = parse_ipsecrequests(xp, pol)) < 0)
  1959. goto out;
  1960. err = xfrm_policy_insert(pol->sadb_x_policy_dir-1, xp,
  1961. hdr->sadb_msg_type != SADB_X_SPDUPDATE);
  1962. xfrm_audit_policy_add(xp, err ? 0 : 1,
  1963. audit_get_loginuid(current->audit_context), 0);
  1964. if (err)
  1965. goto out;
  1966. if (hdr->sadb_msg_type == SADB_X_SPDUPDATE)
  1967. c.event = XFRM_MSG_UPDPOLICY;
  1968. else
  1969. c.event = XFRM_MSG_NEWPOLICY;
  1970. c.seq = hdr->sadb_msg_seq;
  1971. c.pid = hdr->sadb_msg_pid;
  1972. km_policy_notify(xp, pol->sadb_x_policy_dir-1, &c);
  1973. xfrm_pol_put(xp);
  1974. return 0;
  1975. out:
  1976. security_xfrm_policy_free(xp);
  1977. kfree(xp);
  1978. return err;
  1979. }
  1980. static int pfkey_spddelete(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  1981. {
  1982. int err;
  1983. struct sadb_address *sa;
  1984. struct sadb_x_policy *pol;
  1985. struct xfrm_policy *xp, tmp;
  1986. struct xfrm_selector sel;
  1987. struct km_event c;
  1988. struct sadb_x_sec_ctx *sec_ctx;
  1989. if (!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1990. ext_hdrs[SADB_EXT_ADDRESS_DST-1]) ||
  1991. !ext_hdrs[SADB_X_EXT_POLICY-1])
  1992. return -EINVAL;
  1993. pol = ext_hdrs[SADB_X_EXT_POLICY-1];
  1994. if (!pol->sadb_x_policy_dir || pol->sadb_x_policy_dir >= IPSEC_DIR_MAX)
  1995. return -EINVAL;
  1996. memset(&sel, 0, sizeof(sel));
  1997. sa = ext_hdrs[SADB_EXT_ADDRESS_SRC-1],
  1998. sel.family = pfkey_sadb_addr2xfrm_addr(sa, &sel.saddr);
  1999. sel.prefixlen_s = sa->sadb_address_prefixlen;
  2000. sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
  2001. sel.sport = ((struct sockaddr_in *)(sa+1))->sin_port;
  2002. if (sel.sport)
  2003. sel.sport_mask = htons(0xffff);
  2004. sa = ext_hdrs[SADB_EXT_ADDRESS_DST-1],
  2005. pfkey_sadb_addr2xfrm_addr(sa, &sel.daddr);
  2006. sel.prefixlen_d = sa->sadb_address_prefixlen;
  2007. sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
  2008. sel.dport = ((struct sockaddr_in *)(sa+1))->sin_port;
  2009. if (sel.dport)
  2010. sel.dport_mask = htons(0xffff);
  2011. sec_ctx = (struct sadb_x_sec_ctx *) ext_hdrs[SADB_X_EXT_SEC_CTX-1];
  2012. memset(&tmp, 0, sizeof(struct xfrm_policy));
  2013. if (sec_ctx != NULL) {
  2014. struct xfrm_user_sec_ctx *uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx);
  2015. if (!uctx)
  2016. return -ENOMEM;
  2017. err = security_xfrm_policy_alloc(&tmp, uctx);
  2018. kfree(uctx);
  2019. if (err)
  2020. return err;
  2021. }
  2022. xp = xfrm_policy_bysel_ctx(XFRM_POLICY_TYPE_MAIN, pol->sadb_x_policy_dir-1,
  2023. &sel, tmp.security, 1, &err);
  2024. security_xfrm_policy_free(&tmp);
  2025. if (xp == NULL)
  2026. return -ENOENT;
  2027. xfrm_audit_policy_delete(xp, err ? 0 : 1,
  2028. audit_get_loginuid(current->audit_context), 0);
  2029. if (err)
  2030. goto out;
  2031. c.seq = hdr->sadb_msg_seq;
  2032. c.pid = hdr->sadb_msg_pid;
  2033. c.event = XFRM_MSG_DELPOLICY;
  2034. km_policy_notify(xp, pol->sadb_x_policy_dir-1, &c);
  2035. out:
  2036. xfrm_pol_put(xp);
  2037. return err;
  2038. }
  2039. static int key_pol_get_resp(struct sock *sk, struct xfrm_policy *xp, struct sadb_msg *hdr, int dir)
  2040. {
  2041. int err;
  2042. struct sk_buff *out_skb;
  2043. struct sadb_msg *out_hdr;
  2044. err = 0;
  2045. out_skb = pfkey_xfrm_policy2msg_prep(xp);
  2046. if (IS_ERR(out_skb)) {
  2047. err = PTR_ERR(out_skb);
  2048. goto out;
  2049. }
  2050. err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
  2051. if (err < 0)
  2052. goto out;
  2053. out_hdr = (struct sadb_msg *) out_skb->data;
  2054. out_hdr->sadb_msg_version = hdr->sadb_msg_version;
  2055. out_hdr->sadb_msg_type = hdr->sadb_msg_type;
  2056. out_hdr->sadb_msg_satype = 0;
  2057. out_hdr->sadb_msg_errno = 0;
  2058. out_hdr->sadb_msg_seq = hdr->sadb_msg_seq;
  2059. out_hdr->sadb_msg_pid = hdr->sadb_msg_pid;
  2060. pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, sk);
  2061. err = 0;
  2062. out:
  2063. return err;
  2064. }
  2065. #ifdef CONFIG_NET_KEY_MIGRATE
  2066. static int pfkey_sockaddr_pair_size(sa_family_t family)
  2067. {
  2068. switch (family) {
  2069. case AF_INET:
  2070. return PFKEY_ALIGN8(sizeof(struct sockaddr_in) * 2);
  2071. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2072. case AF_INET6:
  2073. return PFKEY_ALIGN8(sizeof(struct sockaddr_in6) * 2);
  2074. #endif
  2075. default:
  2076. return 0;
  2077. }
  2078. /* NOTREACHED */
  2079. }
  2080. static int parse_sockaddr_pair(struct sadb_x_ipsecrequest *rq,
  2081. xfrm_address_t *saddr, xfrm_address_t *daddr,
  2082. u16 *family)
  2083. {
  2084. struct sockaddr *sa = (struct sockaddr *)(rq + 1);
  2085. if (rq->sadb_x_ipsecrequest_len <
  2086. pfkey_sockaddr_pair_size(sa->sa_family))
  2087. return -EINVAL;
  2088. switch (sa->sa_family) {
  2089. case AF_INET:
  2090. {
  2091. struct sockaddr_in *sin;
  2092. sin = (struct sockaddr_in *)sa;
  2093. if ((sin+1)->sin_family != AF_INET)
  2094. return -EINVAL;
  2095. memcpy(&saddr->a4, &sin->sin_addr, sizeof(saddr->a4));
  2096. sin++;
  2097. memcpy(&daddr->a4, &sin->sin_addr, sizeof(daddr->a4));
  2098. *family = AF_INET;
  2099. break;
  2100. }
  2101. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2102. case AF_INET6:
  2103. {
  2104. struct sockaddr_in6 *sin6;
  2105. sin6 = (struct sockaddr_in6 *)sa;
  2106. if ((sin6+1)->sin6_family != AF_INET6)
  2107. return -EINVAL;
  2108. memcpy(&saddr->a6, &sin6->sin6_addr,
  2109. sizeof(saddr->a6));
  2110. sin6++;
  2111. memcpy(&daddr->a6, &sin6->sin6_addr,
  2112. sizeof(daddr->a6));
  2113. *family = AF_INET6;
  2114. break;
  2115. }
  2116. #endif
  2117. default:
  2118. return -EINVAL;
  2119. }
  2120. return 0;
  2121. }
  2122. static int ipsecrequests_to_migrate(struct sadb_x_ipsecrequest *rq1, int len,
  2123. struct xfrm_migrate *m)
  2124. {
  2125. int err;
  2126. struct sadb_x_ipsecrequest *rq2;
  2127. int mode;
  2128. if (len <= sizeof(struct sadb_x_ipsecrequest) ||
  2129. len < rq1->sadb_x_ipsecrequest_len)
  2130. return -EINVAL;
  2131. /* old endoints */
  2132. err = parse_sockaddr_pair(rq1, &m->old_saddr, &m->old_daddr,
  2133. &m->old_family);
  2134. if (err)
  2135. return err;
  2136. rq2 = (struct sadb_x_ipsecrequest *)((u8 *)rq1 + rq1->sadb_x_ipsecrequest_len);
  2137. len -= rq1->sadb_x_ipsecrequest_len;
  2138. if (len <= sizeof(struct sadb_x_ipsecrequest) ||
  2139. len < rq2->sadb_x_ipsecrequest_len)
  2140. return -EINVAL;
  2141. /* new endpoints */
  2142. err = parse_sockaddr_pair(rq2, &m->new_saddr, &m->new_daddr,
  2143. &m->new_family);
  2144. if (err)
  2145. return err;
  2146. if (rq1->sadb_x_ipsecrequest_proto != rq2->sadb_x_ipsecrequest_proto ||
  2147. rq1->sadb_x_ipsecrequest_mode != rq2->sadb_x_ipsecrequest_mode ||
  2148. rq1->sadb_x_ipsecrequest_reqid != rq2->sadb_x_ipsecrequest_reqid)
  2149. return -EINVAL;
  2150. m->proto = rq1->sadb_x_ipsecrequest_proto;
  2151. if ((mode = pfkey_mode_to_xfrm(rq1->sadb_x_ipsecrequest_mode)) < 0)
  2152. return -EINVAL;
  2153. m->mode = mode;
  2154. m->reqid = rq1->sadb_x_ipsecrequest_reqid;
  2155. return ((int)(rq1->sadb_x_ipsecrequest_len +
  2156. rq2->sadb_x_ipsecrequest_len));
  2157. }
  2158. static int pfkey_migrate(struct sock *sk, struct sk_buff *skb,
  2159. struct sadb_msg *hdr, void **ext_hdrs)
  2160. {
  2161. int i, len, ret, err = -EINVAL;
  2162. u8 dir;
  2163. struct sadb_address *sa;
  2164. struct sadb_x_policy *pol;
  2165. struct sadb_x_ipsecrequest *rq;
  2166. struct xfrm_selector sel;
  2167. struct xfrm_migrate m[XFRM_MAX_DEPTH];
  2168. if (!present_and_same_family(ext_hdrs[SADB_EXT_ADDRESS_SRC - 1],
  2169. ext_hdrs[SADB_EXT_ADDRESS_DST - 1]) ||
  2170. !ext_hdrs[SADB_X_EXT_POLICY - 1]) {
  2171. err = -EINVAL;
  2172. goto out;
  2173. }
  2174. pol = ext_hdrs[SADB_X_EXT_POLICY - 1];
  2175. if (!pol) {
  2176. err = -EINVAL;
  2177. goto out;
  2178. }
  2179. if (pol->sadb_x_policy_dir >= IPSEC_DIR_MAX) {
  2180. err = -EINVAL;
  2181. goto out;
  2182. }
  2183. dir = pol->sadb_x_policy_dir - 1;
  2184. memset(&sel, 0, sizeof(sel));
  2185. /* set source address info of selector */
  2186. sa = ext_hdrs[SADB_EXT_ADDRESS_SRC - 1];
  2187. sel.family = pfkey_sadb_addr2xfrm_addr(sa, &sel.saddr);
  2188. sel.prefixlen_s = sa->sadb_address_prefixlen;
  2189. sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
  2190. sel.sport = ((struct sockaddr_in *)(sa + 1))->sin_port;
  2191. if (sel.sport)
  2192. sel.sport_mask = htons(0xffff);
  2193. /* set destination address info of selector */
  2194. sa = ext_hdrs[SADB_EXT_ADDRESS_DST - 1],
  2195. pfkey_sadb_addr2xfrm_addr(sa, &sel.daddr);
  2196. sel.prefixlen_d = sa->sadb_address_prefixlen;
  2197. sel.proto = pfkey_proto_to_xfrm(sa->sadb_address_proto);
  2198. sel.dport = ((struct sockaddr_in *)(sa + 1))->sin_port;
  2199. if (sel.dport)
  2200. sel.dport_mask = htons(0xffff);
  2201. rq = (struct sadb_x_ipsecrequest *)(pol + 1);
  2202. /* extract ipsecrequests */
  2203. i = 0;
  2204. len = pol->sadb_x_policy_len * 8 - sizeof(struct sadb_x_policy);
  2205. while (len > 0 && i < XFRM_MAX_DEPTH) {
  2206. ret = ipsecrequests_to_migrate(rq, len, &m[i]);
  2207. if (ret < 0) {
  2208. err = ret;
  2209. goto out;
  2210. } else {
  2211. rq = (struct sadb_x_ipsecrequest *)((u8 *)rq + ret);
  2212. len -= ret;
  2213. i++;
  2214. }
  2215. }
  2216. if (!i || len > 0) {
  2217. err = -EINVAL;
  2218. goto out;
  2219. }
  2220. return xfrm_migrate(&sel, dir, XFRM_POLICY_TYPE_MAIN, m, i);
  2221. out:
  2222. return err;
  2223. }
  2224. #else
  2225. static int pfkey_migrate(struct sock *sk, struct sk_buff *skb,
  2226. struct sadb_msg *hdr, void **ext_hdrs)
  2227. {
  2228. return -ENOPROTOOPT;
  2229. }
  2230. #endif
  2231. static int pfkey_spdget(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  2232. {
  2233. unsigned int dir;
  2234. int err = 0, delete;
  2235. struct sadb_x_policy *pol;
  2236. struct xfrm_policy *xp;
  2237. struct km_event c;
  2238. if ((pol = ext_hdrs[SADB_X_EXT_POLICY-1]) == NULL)
  2239. return -EINVAL;
  2240. dir = xfrm_policy_id2dir(pol->sadb_x_policy_id);
  2241. if (dir >= XFRM_POLICY_MAX)
  2242. return -EINVAL;
  2243. delete = (hdr->sadb_msg_type == SADB_X_SPDDELETE2);
  2244. xp = xfrm_policy_byid(XFRM_POLICY_TYPE_MAIN, dir, pol->sadb_x_policy_id,
  2245. delete, &err);
  2246. if (xp == NULL)
  2247. return -ENOENT;
  2248. if (delete) {
  2249. xfrm_audit_policy_delete(xp, err ? 0 : 1,
  2250. audit_get_loginuid(current->audit_context), 0);
  2251. if (err)
  2252. goto out;
  2253. c.seq = hdr->sadb_msg_seq;
  2254. c.pid = hdr->sadb_msg_pid;
  2255. c.data.byid = 1;
  2256. c.event = XFRM_MSG_DELPOLICY;
  2257. km_policy_notify(xp, dir, &c);
  2258. } else {
  2259. err = key_pol_get_resp(sk, xp, hdr, dir);
  2260. }
  2261. out:
  2262. xfrm_pol_put(xp);
  2263. return err;
  2264. }
  2265. static int dump_sp(struct xfrm_policy *xp, int dir, int count, void *ptr)
  2266. {
  2267. struct pfkey_dump_data *data = ptr;
  2268. struct sk_buff *out_skb;
  2269. struct sadb_msg *out_hdr;
  2270. int err;
  2271. out_skb = pfkey_xfrm_policy2msg_prep(xp);
  2272. if (IS_ERR(out_skb))
  2273. return PTR_ERR(out_skb);
  2274. err = pfkey_xfrm_policy2msg(out_skb, xp, dir);
  2275. if (err < 0)
  2276. return err;
  2277. out_hdr = (struct sadb_msg *) out_skb->data;
  2278. out_hdr->sadb_msg_version = data->hdr->sadb_msg_version;
  2279. out_hdr->sadb_msg_type = SADB_X_SPDDUMP;
  2280. out_hdr->sadb_msg_satype = SADB_SATYPE_UNSPEC;
  2281. out_hdr->sadb_msg_errno = 0;
  2282. out_hdr->sadb_msg_seq = count;
  2283. out_hdr->sadb_msg_pid = data->hdr->sadb_msg_pid;
  2284. pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_ONE, data->sk);
  2285. return 0;
  2286. }
  2287. static int pfkey_spddump(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  2288. {
  2289. struct pfkey_dump_data data = { .skb = skb, .hdr = hdr, .sk = sk };
  2290. return xfrm_policy_walk(XFRM_POLICY_TYPE_MAIN, dump_sp, &data);
  2291. }
  2292. static int key_notify_policy_flush(struct km_event *c)
  2293. {
  2294. struct sk_buff *skb_out;
  2295. struct sadb_msg *hdr;
  2296. skb_out = alloc_skb(sizeof(struct sadb_msg) + 16, GFP_ATOMIC);
  2297. if (!skb_out)
  2298. return -ENOBUFS;
  2299. hdr = (struct sadb_msg *) skb_put(skb_out, sizeof(struct sadb_msg));
  2300. hdr->sadb_msg_type = SADB_X_SPDFLUSH;
  2301. hdr->sadb_msg_seq = c->seq;
  2302. hdr->sadb_msg_pid = c->pid;
  2303. hdr->sadb_msg_version = PF_KEY_V2;
  2304. hdr->sadb_msg_errno = (uint8_t) 0;
  2305. hdr->sadb_msg_len = (sizeof(struct sadb_msg) / sizeof(uint64_t));
  2306. pfkey_broadcast(skb_out, GFP_ATOMIC, BROADCAST_ALL, NULL);
  2307. return 0;
  2308. }
  2309. static int pfkey_spdflush(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr, void **ext_hdrs)
  2310. {
  2311. struct km_event c;
  2312. struct xfrm_audit audit_info;
  2313. int err;
  2314. audit_info.loginuid = audit_get_loginuid(current->audit_context);
  2315. audit_info.secid = 0;
  2316. err = xfrm_policy_flush(XFRM_POLICY_TYPE_MAIN, &audit_info);
  2317. if (err)
  2318. return err;
  2319. c.data.type = XFRM_POLICY_TYPE_MAIN;
  2320. c.event = XFRM_MSG_FLUSHPOLICY;
  2321. c.pid = hdr->sadb_msg_pid;
  2322. c.seq = hdr->sadb_msg_seq;
  2323. km_policy_notify(NULL, 0, &c);
  2324. return 0;
  2325. }
  2326. typedef int (*pfkey_handler)(struct sock *sk, struct sk_buff *skb,
  2327. struct sadb_msg *hdr, void **ext_hdrs);
  2328. static pfkey_handler pfkey_funcs[SADB_MAX + 1] = {
  2329. [SADB_RESERVED] = pfkey_reserved,
  2330. [SADB_GETSPI] = pfkey_getspi,
  2331. [SADB_UPDATE] = pfkey_add,
  2332. [SADB_ADD] = pfkey_add,
  2333. [SADB_DELETE] = pfkey_delete,
  2334. [SADB_GET] = pfkey_get,
  2335. [SADB_ACQUIRE] = pfkey_acquire,
  2336. [SADB_REGISTER] = pfkey_register,
  2337. [SADB_EXPIRE] = NULL,
  2338. [SADB_FLUSH] = pfkey_flush,
  2339. [SADB_DUMP] = pfkey_dump,
  2340. [SADB_X_PROMISC] = pfkey_promisc,
  2341. [SADB_X_PCHANGE] = NULL,
  2342. [SADB_X_SPDUPDATE] = pfkey_spdadd,
  2343. [SADB_X_SPDADD] = pfkey_spdadd,
  2344. [SADB_X_SPDDELETE] = pfkey_spddelete,
  2345. [SADB_X_SPDGET] = pfkey_spdget,
  2346. [SADB_X_SPDACQUIRE] = NULL,
  2347. [SADB_X_SPDDUMP] = pfkey_spddump,
  2348. [SADB_X_SPDFLUSH] = pfkey_spdflush,
  2349. [SADB_X_SPDSETIDX] = pfkey_spdadd,
  2350. [SADB_X_SPDDELETE2] = pfkey_spdget,
  2351. [SADB_X_MIGRATE] = pfkey_migrate,
  2352. };
  2353. static int pfkey_process(struct sock *sk, struct sk_buff *skb, struct sadb_msg *hdr)
  2354. {
  2355. void *ext_hdrs[SADB_EXT_MAX];
  2356. int err;
  2357. pfkey_broadcast(skb_clone(skb, GFP_KERNEL), GFP_KERNEL,
  2358. BROADCAST_PROMISC_ONLY, NULL);
  2359. memset(ext_hdrs, 0, sizeof(ext_hdrs));
  2360. err = parse_exthdrs(skb, hdr, ext_hdrs);
  2361. if (!err) {
  2362. err = -EOPNOTSUPP;
  2363. if (pfkey_funcs[hdr->sadb_msg_type])
  2364. err = pfkey_funcs[hdr->sadb_msg_type](sk, skb, hdr, ext_hdrs);
  2365. }
  2366. return err;
  2367. }
  2368. static struct sadb_msg *pfkey_get_base_msg(struct sk_buff *skb, int *errp)
  2369. {
  2370. struct sadb_msg *hdr = NULL;
  2371. if (skb->len < sizeof(*hdr)) {
  2372. *errp = -EMSGSIZE;
  2373. } else {
  2374. hdr = (struct sadb_msg *) skb->data;
  2375. if (hdr->sadb_msg_version != PF_KEY_V2 ||
  2376. hdr->sadb_msg_reserved != 0 ||
  2377. (hdr->sadb_msg_type <= SADB_RESERVED ||
  2378. hdr->sadb_msg_type > SADB_MAX)) {
  2379. hdr = NULL;
  2380. *errp = -EINVAL;
  2381. } else if (hdr->sadb_msg_len != (skb->len /
  2382. sizeof(uint64_t)) ||
  2383. hdr->sadb_msg_len < (sizeof(struct sadb_msg) /
  2384. sizeof(uint64_t))) {
  2385. hdr = NULL;
  2386. *errp = -EMSGSIZE;
  2387. } else {
  2388. *errp = 0;
  2389. }
  2390. }
  2391. return hdr;
  2392. }
  2393. static inline int aalg_tmpl_set(struct xfrm_tmpl *t, struct xfrm_algo_desc *d)
  2394. {
  2395. return t->aalgos & (1 << d->desc.sadb_alg_id);
  2396. }
  2397. static inline int ealg_tmpl_set(struct xfrm_tmpl *t, struct xfrm_algo_desc *d)
  2398. {
  2399. return t->ealgos & (1 << d->desc.sadb_alg_id);
  2400. }
  2401. static int count_ah_combs(struct xfrm_tmpl *t)
  2402. {
  2403. int i, sz = 0;
  2404. for (i = 0; ; i++) {
  2405. struct xfrm_algo_desc *aalg = xfrm_aalg_get_byidx(i);
  2406. if (!aalg)
  2407. break;
  2408. if (aalg_tmpl_set(t, aalg) && aalg->available)
  2409. sz += sizeof(struct sadb_comb);
  2410. }
  2411. return sz + sizeof(struct sadb_prop);
  2412. }
  2413. static int count_esp_combs(struct xfrm_tmpl *t)
  2414. {
  2415. int i, k, sz = 0;
  2416. for (i = 0; ; i++) {
  2417. struct xfrm_algo_desc *ealg = xfrm_ealg_get_byidx(i);
  2418. if (!ealg)
  2419. break;
  2420. if (!(ealg_tmpl_set(t, ealg) && ealg->available))
  2421. continue;
  2422. for (k = 1; ; k++) {
  2423. struct xfrm_algo_desc *aalg = xfrm_aalg_get_byidx(k);
  2424. if (!aalg)
  2425. break;
  2426. if (aalg_tmpl_set(t, aalg) && aalg->available)
  2427. sz += sizeof(struct sadb_comb);
  2428. }
  2429. }
  2430. return sz + sizeof(struct sadb_prop);
  2431. }
  2432. static void dump_ah_combs(struct sk_buff *skb, struct xfrm_tmpl *t)
  2433. {
  2434. struct sadb_prop *p;
  2435. int i;
  2436. p = (struct sadb_prop*)skb_put(skb, sizeof(struct sadb_prop));
  2437. p->sadb_prop_len = sizeof(struct sadb_prop)/8;
  2438. p->sadb_prop_exttype = SADB_EXT_PROPOSAL;
  2439. p->sadb_prop_replay = 32;
  2440. memset(p->sadb_prop_reserved, 0, sizeof(p->sadb_prop_reserved));
  2441. for (i = 0; ; i++) {
  2442. struct xfrm_algo_desc *aalg = xfrm_aalg_get_byidx(i);
  2443. if (!aalg)
  2444. break;
  2445. if (aalg_tmpl_set(t, aalg) && aalg->available) {
  2446. struct sadb_comb *c;
  2447. c = (struct sadb_comb*)skb_put(skb, sizeof(struct sadb_comb));
  2448. memset(c, 0, sizeof(*c));
  2449. p->sadb_prop_len += sizeof(struct sadb_comb)/8;
  2450. c->sadb_comb_auth = aalg->desc.sadb_alg_id;
  2451. c->sadb_comb_auth_minbits = aalg->desc.sadb_alg_minbits;
  2452. c->sadb_comb_auth_maxbits = aalg->desc.sadb_alg_maxbits;
  2453. c->sadb_comb_hard_addtime = 24*60*60;
  2454. c->sadb_comb_soft_addtime = 20*60*60;
  2455. c->sadb_comb_hard_usetime = 8*60*60;
  2456. c->sadb_comb_soft_usetime = 7*60*60;
  2457. }
  2458. }
  2459. }
  2460. static void dump_esp_combs(struct sk_buff *skb, struct xfrm_tmpl *t)
  2461. {
  2462. struct sadb_prop *p;
  2463. int i, k;
  2464. p = (struct sadb_prop*)skb_put(skb, sizeof(struct sadb_prop));
  2465. p->sadb_prop_len = sizeof(struct sadb_prop)/8;
  2466. p->sadb_prop_exttype = SADB_EXT_PROPOSAL;
  2467. p->sadb_prop_replay = 32;
  2468. memset(p->sadb_prop_reserved, 0, sizeof(p->sadb_prop_reserved));
  2469. for (i=0; ; i++) {
  2470. struct xfrm_algo_desc *ealg = xfrm_ealg_get_byidx(i);
  2471. if (!ealg)
  2472. break;
  2473. if (!(ealg_tmpl_set(t, ealg) && ealg->available))
  2474. continue;
  2475. for (k = 1; ; k++) {
  2476. struct sadb_comb *c;
  2477. struct xfrm_algo_desc *aalg = xfrm_aalg_get_byidx(k);
  2478. if (!aalg)
  2479. break;
  2480. if (!(aalg_tmpl_set(t, aalg) && aalg->available))
  2481. continue;
  2482. c = (struct sadb_comb*)skb_put(skb, sizeof(struct sadb_comb));
  2483. memset(c, 0, sizeof(*c));
  2484. p->sadb_prop_len += sizeof(struct sadb_comb)/8;
  2485. c->sadb_comb_auth = aalg->desc.sadb_alg_id;
  2486. c->sadb_comb_auth_minbits = aalg->desc.sadb_alg_minbits;
  2487. c->sadb_comb_auth_maxbits = aalg->desc.sadb_alg_maxbits;
  2488. c->sadb_comb_encrypt = ealg->desc.sadb_alg_id;
  2489. c->sadb_comb_encrypt_minbits = ealg->desc.sadb_alg_minbits;
  2490. c->sadb_comb_encrypt_maxbits = ealg->desc.sadb_alg_maxbits;
  2491. c->sadb_comb_hard_addtime = 24*60*60;
  2492. c->sadb_comb_soft_addtime = 20*60*60;
  2493. c->sadb_comb_hard_usetime = 8*60*60;
  2494. c->sadb_comb_soft_usetime = 7*60*60;
  2495. }
  2496. }
  2497. }
  2498. static int key_notify_policy_expire(struct xfrm_policy *xp, struct km_event *c)
  2499. {
  2500. return 0;
  2501. }
  2502. static int key_notify_sa_expire(struct xfrm_state *x, struct km_event *c)
  2503. {
  2504. struct sk_buff *out_skb;
  2505. struct sadb_msg *out_hdr;
  2506. int hard;
  2507. int hsc;
  2508. hard = c->data.hard;
  2509. if (hard)
  2510. hsc = 2;
  2511. else
  2512. hsc = 1;
  2513. out_skb = pfkey_xfrm_state2msg(x, 0, hsc);
  2514. if (IS_ERR(out_skb))
  2515. return PTR_ERR(out_skb);
  2516. out_hdr = (struct sadb_msg *) out_skb->data;
  2517. out_hdr->sadb_msg_version = PF_KEY_V2;
  2518. out_hdr->sadb_msg_type = SADB_EXPIRE;
  2519. out_hdr->sadb_msg_satype = pfkey_proto2satype(x->id.proto);
  2520. out_hdr->sadb_msg_errno = 0;
  2521. out_hdr->sadb_msg_reserved = 0;
  2522. out_hdr->sadb_msg_seq = 0;
  2523. out_hdr->sadb_msg_pid = 0;
  2524. pfkey_broadcast(out_skb, GFP_ATOMIC, BROADCAST_REGISTERED, NULL);
  2525. return 0;
  2526. }
  2527. static int pfkey_send_notify(struct xfrm_state *x, struct km_event *c)
  2528. {
  2529. switch (c->event) {
  2530. case XFRM_MSG_EXPIRE:
  2531. return key_notify_sa_expire(x, c);
  2532. case XFRM_MSG_DELSA:
  2533. case XFRM_MSG_NEWSA:
  2534. case XFRM_MSG_UPDSA:
  2535. return key_notify_sa(x, c);
  2536. case XFRM_MSG_FLUSHSA:
  2537. return key_notify_sa_flush(c);
  2538. case XFRM_MSG_NEWAE: /* not yet supported */
  2539. break;
  2540. default:
  2541. printk("pfkey: Unknown SA event %d\n", c->event);
  2542. break;
  2543. }
  2544. return 0;
  2545. }
  2546. static int pfkey_send_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
  2547. {
  2548. if (xp && xp->type != XFRM_POLICY_TYPE_MAIN)
  2549. return 0;
  2550. switch (c->event) {
  2551. case XFRM_MSG_POLEXPIRE:
  2552. return key_notify_policy_expire(xp, c);
  2553. case XFRM_MSG_DELPOLICY:
  2554. case XFRM_MSG_NEWPOLICY:
  2555. case XFRM_MSG_UPDPOLICY:
  2556. return key_notify_policy(xp, dir, c);
  2557. case XFRM_MSG_FLUSHPOLICY:
  2558. if (c->data.type != XFRM_POLICY_TYPE_MAIN)
  2559. break;
  2560. return key_notify_policy_flush(c);
  2561. default:
  2562. printk("pfkey: Unknown policy event %d\n", c->event);
  2563. break;
  2564. }
  2565. return 0;
  2566. }
  2567. static u32 get_acqseq(void)
  2568. {
  2569. u32 res;
  2570. static u32 acqseq;
  2571. static DEFINE_SPINLOCK(acqseq_lock);
  2572. spin_lock_bh(&acqseq_lock);
  2573. res = (++acqseq ? : ++acqseq);
  2574. spin_unlock_bh(&acqseq_lock);
  2575. return res;
  2576. }
  2577. static int pfkey_send_acquire(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *xp, int dir)
  2578. {
  2579. struct sk_buff *skb;
  2580. struct sadb_msg *hdr;
  2581. struct sadb_address *addr;
  2582. struct sadb_x_policy *pol;
  2583. struct sockaddr_in *sin;
  2584. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2585. struct sockaddr_in6 *sin6;
  2586. #endif
  2587. int sockaddr_size;
  2588. int size;
  2589. struct sadb_x_sec_ctx *sec_ctx;
  2590. struct xfrm_sec_ctx *xfrm_ctx;
  2591. int ctx_size = 0;
  2592. sockaddr_size = pfkey_sockaddr_size(x->props.family);
  2593. if (!sockaddr_size)
  2594. return -EINVAL;
  2595. size = sizeof(struct sadb_msg) +
  2596. (sizeof(struct sadb_address) * 2) +
  2597. (sockaddr_size * 2) +
  2598. sizeof(struct sadb_x_policy);
  2599. if (x->id.proto == IPPROTO_AH)
  2600. size += count_ah_combs(t);
  2601. else if (x->id.proto == IPPROTO_ESP)
  2602. size += count_esp_combs(t);
  2603. if ((xfrm_ctx = x->security)) {
  2604. ctx_size = PFKEY_ALIGN8(xfrm_ctx->ctx_len);
  2605. size += sizeof(struct sadb_x_sec_ctx) + ctx_size;
  2606. }
  2607. skb = alloc_skb(size + 16, GFP_ATOMIC);
  2608. if (skb == NULL)
  2609. return -ENOMEM;
  2610. hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
  2611. hdr->sadb_msg_version = PF_KEY_V2;
  2612. hdr->sadb_msg_type = SADB_ACQUIRE;
  2613. hdr->sadb_msg_satype = pfkey_proto2satype(x->id.proto);
  2614. hdr->sadb_msg_len = size / sizeof(uint64_t);
  2615. hdr->sadb_msg_errno = 0;
  2616. hdr->sadb_msg_reserved = 0;
  2617. hdr->sadb_msg_seq = x->km.seq = get_acqseq();
  2618. hdr->sadb_msg_pid = 0;
  2619. /* src address */
  2620. addr = (struct sadb_address*) skb_put(skb,
  2621. sizeof(struct sadb_address)+sockaddr_size);
  2622. addr->sadb_address_len =
  2623. (sizeof(struct sadb_address)+sockaddr_size)/
  2624. sizeof(uint64_t);
  2625. addr->sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
  2626. addr->sadb_address_proto = 0;
  2627. addr->sadb_address_reserved = 0;
  2628. if (x->props.family == AF_INET) {
  2629. addr->sadb_address_prefixlen = 32;
  2630. sin = (struct sockaddr_in *) (addr + 1);
  2631. sin->sin_family = AF_INET;
  2632. sin->sin_addr.s_addr = x->props.saddr.a4;
  2633. sin->sin_port = 0;
  2634. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  2635. }
  2636. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2637. else if (x->props.family == AF_INET6) {
  2638. addr->sadb_address_prefixlen = 128;
  2639. sin6 = (struct sockaddr_in6 *) (addr + 1);
  2640. sin6->sin6_family = AF_INET6;
  2641. sin6->sin6_port = 0;
  2642. sin6->sin6_flowinfo = 0;
  2643. memcpy(&sin6->sin6_addr,
  2644. x->props.saddr.a6, sizeof(struct in6_addr));
  2645. sin6->sin6_scope_id = 0;
  2646. }
  2647. #endif
  2648. else
  2649. BUG();
  2650. /* dst address */
  2651. addr = (struct sadb_address*) skb_put(skb,
  2652. sizeof(struct sadb_address)+sockaddr_size);
  2653. addr->sadb_address_len =
  2654. (sizeof(struct sadb_address)+sockaddr_size)/
  2655. sizeof(uint64_t);
  2656. addr->sadb_address_exttype = SADB_EXT_ADDRESS_DST;
  2657. addr->sadb_address_proto = 0;
  2658. addr->sadb_address_reserved = 0;
  2659. if (x->props.family == AF_INET) {
  2660. addr->sadb_address_prefixlen = 32;
  2661. sin = (struct sockaddr_in *) (addr + 1);
  2662. sin->sin_family = AF_INET;
  2663. sin->sin_addr.s_addr = x->id.daddr.a4;
  2664. sin->sin_port = 0;
  2665. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  2666. }
  2667. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2668. else if (x->props.family == AF_INET6) {
  2669. addr->sadb_address_prefixlen = 128;
  2670. sin6 = (struct sockaddr_in6 *) (addr + 1);
  2671. sin6->sin6_family = AF_INET6;
  2672. sin6->sin6_port = 0;
  2673. sin6->sin6_flowinfo = 0;
  2674. memcpy(&sin6->sin6_addr,
  2675. x->id.daddr.a6, sizeof(struct in6_addr));
  2676. sin6->sin6_scope_id = 0;
  2677. }
  2678. #endif
  2679. else
  2680. BUG();
  2681. pol = (struct sadb_x_policy *) skb_put(skb, sizeof(struct sadb_x_policy));
  2682. pol->sadb_x_policy_len = sizeof(struct sadb_x_policy)/sizeof(uint64_t);
  2683. pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
  2684. pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;
  2685. pol->sadb_x_policy_dir = dir+1;
  2686. pol->sadb_x_policy_id = xp->index;
  2687. /* Set sadb_comb's. */
  2688. if (x->id.proto == IPPROTO_AH)
  2689. dump_ah_combs(skb, t);
  2690. else if (x->id.proto == IPPROTO_ESP)
  2691. dump_esp_combs(skb, t);
  2692. /* security context */
  2693. if (xfrm_ctx) {
  2694. sec_ctx = (struct sadb_x_sec_ctx *) skb_put(skb,
  2695. sizeof(struct sadb_x_sec_ctx) + ctx_size);
  2696. sec_ctx->sadb_x_sec_len =
  2697. (sizeof(struct sadb_x_sec_ctx) + ctx_size) / sizeof(uint64_t);
  2698. sec_ctx->sadb_x_sec_exttype = SADB_X_EXT_SEC_CTX;
  2699. sec_ctx->sadb_x_ctx_doi = xfrm_ctx->ctx_doi;
  2700. sec_ctx->sadb_x_ctx_alg = xfrm_ctx->ctx_alg;
  2701. sec_ctx->sadb_x_ctx_len = xfrm_ctx->ctx_len;
  2702. memcpy(sec_ctx + 1, xfrm_ctx->ctx_str,
  2703. xfrm_ctx->ctx_len);
  2704. }
  2705. return pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_REGISTERED, NULL);
  2706. }
  2707. static struct xfrm_policy *pfkey_compile_policy(struct sock *sk, int opt,
  2708. u8 *data, int len, int *dir)
  2709. {
  2710. struct xfrm_policy *xp;
  2711. struct sadb_x_policy *pol = (struct sadb_x_policy*)data;
  2712. struct sadb_x_sec_ctx *sec_ctx;
  2713. switch (sk->sk_family) {
  2714. case AF_INET:
  2715. if (opt != IP_IPSEC_POLICY) {
  2716. *dir = -EOPNOTSUPP;
  2717. return NULL;
  2718. }
  2719. break;
  2720. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2721. case AF_INET6:
  2722. if (opt != IPV6_IPSEC_POLICY) {
  2723. *dir = -EOPNOTSUPP;
  2724. return NULL;
  2725. }
  2726. break;
  2727. #endif
  2728. default:
  2729. *dir = -EINVAL;
  2730. return NULL;
  2731. }
  2732. *dir = -EINVAL;
  2733. if (len < sizeof(struct sadb_x_policy) ||
  2734. pol->sadb_x_policy_len*8 > len ||
  2735. pol->sadb_x_policy_type > IPSEC_POLICY_BYPASS ||
  2736. (!pol->sadb_x_policy_dir || pol->sadb_x_policy_dir > IPSEC_DIR_OUTBOUND))
  2737. return NULL;
  2738. xp = xfrm_policy_alloc(GFP_ATOMIC);
  2739. if (xp == NULL) {
  2740. *dir = -ENOBUFS;
  2741. return NULL;
  2742. }
  2743. xp->action = (pol->sadb_x_policy_type == IPSEC_POLICY_DISCARD ?
  2744. XFRM_POLICY_BLOCK : XFRM_POLICY_ALLOW);
  2745. xp->lft.soft_byte_limit = XFRM_INF;
  2746. xp->lft.hard_byte_limit = XFRM_INF;
  2747. xp->lft.soft_packet_limit = XFRM_INF;
  2748. xp->lft.hard_packet_limit = XFRM_INF;
  2749. xp->family = sk->sk_family;
  2750. xp->xfrm_nr = 0;
  2751. if (pol->sadb_x_policy_type == IPSEC_POLICY_IPSEC &&
  2752. (*dir = parse_ipsecrequests(xp, pol)) < 0)
  2753. goto out;
  2754. /* security context too */
  2755. if (len >= (pol->sadb_x_policy_len*8 +
  2756. sizeof(struct sadb_x_sec_ctx))) {
  2757. char *p = (char *)pol;
  2758. struct xfrm_user_sec_ctx *uctx;
  2759. p += pol->sadb_x_policy_len*8;
  2760. sec_ctx = (struct sadb_x_sec_ctx *)p;
  2761. if (len < pol->sadb_x_policy_len*8 +
  2762. sec_ctx->sadb_x_sec_len) {
  2763. *dir = -EINVAL;
  2764. goto out;
  2765. }
  2766. if ((*dir = verify_sec_ctx_len(p)))
  2767. goto out;
  2768. uctx = pfkey_sadb2xfrm_user_sec_ctx(sec_ctx);
  2769. *dir = security_xfrm_policy_alloc(xp, uctx);
  2770. kfree(uctx);
  2771. if (*dir)
  2772. goto out;
  2773. }
  2774. *dir = pol->sadb_x_policy_dir-1;
  2775. return xp;
  2776. out:
  2777. security_xfrm_policy_free(xp);
  2778. kfree(xp);
  2779. return NULL;
  2780. }
  2781. static int pfkey_send_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport)
  2782. {
  2783. struct sk_buff *skb;
  2784. struct sadb_msg *hdr;
  2785. struct sadb_sa *sa;
  2786. struct sadb_address *addr;
  2787. struct sadb_x_nat_t_port *n_port;
  2788. struct sockaddr_in *sin;
  2789. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2790. struct sockaddr_in6 *sin6;
  2791. #endif
  2792. int sockaddr_size;
  2793. int size;
  2794. __u8 satype = (x->id.proto == IPPROTO_ESP ? SADB_SATYPE_ESP : 0);
  2795. struct xfrm_encap_tmpl *natt = NULL;
  2796. sockaddr_size = pfkey_sockaddr_size(x->props.family);
  2797. if (!sockaddr_size)
  2798. return -EINVAL;
  2799. if (!satype)
  2800. return -EINVAL;
  2801. if (!x->encap)
  2802. return -EINVAL;
  2803. natt = x->encap;
  2804. /* Build an SADB_X_NAT_T_NEW_MAPPING message:
  2805. *
  2806. * HDR | SA | ADDRESS_SRC (old addr) | NAT_T_SPORT (old port) |
  2807. * ADDRESS_DST (new addr) | NAT_T_DPORT (new port)
  2808. */
  2809. size = sizeof(struct sadb_msg) +
  2810. sizeof(struct sadb_sa) +
  2811. (sizeof(struct sadb_address) * 2) +
  2812. (sockaddr_size * 2) +
  2813. (sizeof(struct sadb_x_nat_t_port) * 2);
  2814. skb = alloc_skb(size + 16, GFP_ATOMIC);
  2815. if (skb == NULL)
  2816. return -ENOMEM;
  2817. hdr = (struct sadb_msg *) skb_put(skb, sizeof(struct sadb_msg));
  2818. hdr->sadb_msg_version = PF_KEY_V2;
  2819. hdr->sadb_msg_type = SADB_X_NAT_T_NEW_MAPPING;
  2820. hdr->sadb_msg_satype = satype;
  2821. hdr->sadb_msg_len = size / sizeof(uint64_t);
  2822. hdr->sadb_msg_errno = 0;
  2823. hdr->sadb_msg_reserved = 0;
  2824. hdr->sadb_msg_seq = x->km.seq = get_acqseq();
  2825. hdr->sadb_msg_pid = 0;
  2826. /* SA */
  2827. sa = (struct sadb_sa *) skb_put(skb, sizeof(struct sadb_sa));
  2828. sa->sadb_sa_len = sizeof(struct sadb_sa)/sizeof(uint64_t);
  2829. sa->sadb_sa_exttype = SADB_EXT_SA;
  2830. sa->sadb_sa_spi = x->id.spi;
  2831. sa->sadb_sa_replay = 0;
  2832. sa->sadb_sa_state = 0;
  2833. sa->sadb_sa_auth = 0;
  2834. sa->sadb_sa_encrypt = 0;
  2835. sa->sadb_sa_flags = 0;
  2836. /* ADDRESS_SRC (old addr) */
  2837. addr = (struct sadb_address*)
  2838. skb_put(skb, sizeof(struct sadb_address)+sockaddr_size);
  2839. addr->sadb_address_len =
  2840. (sizeof(struct sadb_address)+sockaddr_size)/
  2841. sizeof(uint64_t);
  2842. addr->sadb_address_exttype = SADB_EXT_ADDRESS_SRC;
  2843. addr->sadb_address_proto = 0;
  2844. addr->sadb_address_reserved = 0;
  2845. if (x->props.family == AF_INET) {
  2846. addr->sadb_address_prefixlen = 32;
  2847. sin = (struct sockaddr_in *) (addr + 1);
  2848. sin->sin_family = AF_INET;
  2849. sin->sin_addr.s_addr = x->props.saddr.a4;
  2850. sin->sin_port = 0;
  2851. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  2852. }
  2853. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2854. else if (x->props.family == AF_INET6) {
  2855. addr->sadb_address_prefixlen = 128;
  2856. sin6 = (struct sockaddr_in6 *) (addr + 1);
  2857. sin6->sin6_family = AF_INET6;
  2858. sin6->sin6_port = 0;
  2859. sin6->sin6_flowinfo = 0;
  2860. memcpy(&sin6->sin6_addr,
  2861. x->props.saddr.a6, sizeof(struct in6_addr));
  2862. sin6->sin6_scope_id = 0;
  2863. }
  2864. #endif
  2865. else
  2866. BUG();
  2867. /* NAT_T_SPORT (old port) */
  2868. n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
  2869. n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
  2870. n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_SPORT;
  2871. n_port->sadb_x_nat_t_port_port = natt->encap_sport;
  2872. n_port->sadb_x_nat_t_port_reserved = 0;
  2873. /* ADDRESS_DST (new addr) */
  2874. addr = (struct sadb_address*)
  2875. skb_put(skb, sizeof(struct sadb_address)+sockaddr_size);
  2876. addr->sadb_address_len =
  2877. (sizeof(struct sadb_address)+sockaddr_size)/
  2878. sizeof(uint64_t);
  2879. addr->sadb_address_exttype = SADB_EXT_ADDRESS_DST;
  2880. addr->sadb_address_proto = 0;
  2881. addr->sadb_address_reserved = 0;
  2882. if (x->props.family == AF_INET) {
  2883. addr->sadb_address_prefixlen = 32;
  2884. sin = (struct sockaddr_in *) (addr + 1);
  2885. sin->sin_family = AF_INET;
  2886. sin->sin_addr.s_addr = ipaddr->a4;
  2887. sin->sin_port = 0;
  2888. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  2889. }
  2890. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2891. else if (x->props.family == AF_INET6) {
  2892. addr->sadb_address_prefixlen = 128;
  2893. sin6 = (struct sockaddr_in6 *) (addr + 1);
  2894. sin6->sin6_family = AF_INET6;
  2895. sin6->sin6_port = 0;
  2896. sin6->sin6_flowinfo = 0;
  2897. memcpy(&sin6->sin6_addr, &ipaddr->a6, sizeof(struct in6_addr));
  2898. sin6->sin6_scope_id = 0;
  2899. }
  2900. #endif
  2901. else
  2902. BUG();
  2903. /* NAT_T_DPORT (new port) */
  2904. n_port = (struct sadb_x_nat_t_port*) skb_put(skb, sizeof (*n_port));
  2905. n_port->sadb_x_nat_t_port_len = sizeof(*n_port)/sizeof(uint64_t);
  2906. n_port->sadb_x_nat_t_port_exttype = SADB_X_EXT_NAT_T_DPORT;
  2907. n_port->sadb_x_nat_t_port_port = sport;
  2908. n_port->sadb_x_nat_t_port_reserved = 0;
  2909. return pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_REGISTERED, NULL);
  2910. }
  2911. #ifdef CONFIG_NET_KEY_MIGRATE
  2912. static int set_sadb_address(struct sk_buff *skb, int sasize, int type,
  2913. struct xfrm_selector *sel)
  2914. {
  2915. struct sadb_address *addr;
  2916. struct sockaddr_in *sin;
  2917. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2918. struct sockaddr_in6 *sin6;
  2919. #endif
  2920. addr = (struct sadb_address *)skb_put(skb, sizeof(struct sadb_address) + sasize);
  2921. addr->sadb_address_len = (sizeof(struct sadb_address) + sasize)/8;
  2922. addr->sadb_address_exttype = type;
  2923. addr->sadb_address_proto = sel->proto;
  2924. addr->sadb_address_reserved = 0;
  2925. switch (type) {
  2926. case SADB_EXT_ADDRESS_SRC:
  2927. if (sel->family == AF_INET) {
  2928. addr->sadb_address_prefixlen = sel->prefixlen_s;
  2929. sin = (struct sockaddr_in *)(addr + 1);
  2930. sin->sin_family = AF_INET;
  2931. memcpy(&sin->sin_addr.s_addr, &sel->saddr,
  2932. sizeof(sin->sin_addr.s_addr));
  2933. sin->sin_port = 0;
  2934. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  2935. }
  2936. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2937. else if (sel->family == AF_INET6) {
  2938. addr->sadb_address_prefixlen = sel->prefixlen_s;
  2939. sin6 = (struct sockaddr_in6 *)(addr + 1);
  2940. sin6->sin6_family = AF_INET6;
  2941. sin6->sin6_port = 0;
  2942. sin6->sin6_flowinfo = 0;
  2943. sin6->sin6_scope_id = 0;
  2944. memcpy(&sin6->sin6_addr.s6_addr, &sel->saddr,
  2945. sizeof(sin6->sin6_addr.s6_addr));
  2946. }
  2947. #endif
  2948. break;
  2949. case SADB_EXT_ADDRESS_DST:
  2950. if (sel->family == AF_INET) {
  2951. addr->sadb_address_prefixlen = sel->prefixlen_d;
  2952. sin = (struct sockaddr_in *)(addr + 1);
  2953. sin->sin_family = AF_INET;
  2954. memcpy(&sin->sin_addr.s_addr, &sel->daddr,
  2955. sizeof(sin->sin_addr.s_addr));
  2956. sin->sin_port = 0;
  2957. memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
  2958. }
  2959. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2960. else if (sel->family == AF_INET6) {
  2961. addr->sadb_address_prefixlen = sel->prefixlen_d;
  2962. sin6 = (struct sockaddr_in6 *)(addr + 1);
  2963. sin6->sin6_family = AF_INET6;
  2964. sin6->sin6_port = 0;
  2965. sin6->sin6_flowinfo = 0;
  2966. sin6->sin6_scope_id = 0;
  2967. memcpy(&sin6->sin6_addr.s6_addr, &sel->daddr,
  2968. sizeof(sin6->sin6_addr.s6_addr));
  2969. }
  2970. #endif
  2971. break;
  2972. default:
  2973. return -EINVAL;
  2974. }
  2975. return 0;
  2976. }
  2977. static int set_ipsecrequest(struct sk_buff *skb,
  2978. uint8_t proto, uint8_t mode, int level,
  2979. uint32_t reqid, uint8_t family,
  2980. xfrm_address_t *src, xfrm_address_t *dst)
  2981. {
  2982. struct sadb_x_ipsecrequest *rq;
  2983. struct sockaddr_in *sin;
  2984. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  2985. struct sockaddr_in6 *sin6;
  2986. #endif
  2987. int size_req;
  2988. size_req = sizeof(struct sadb_x_ipsecrequest) +
  2989. pfkey_sockaddr_pair_size(family);
  2990. rq = (struct sadb_x_ipsecrequest *)skb_put(skb, size_req);
  2991. memset(rq, 0, size_req);
  2992. rq->sadb_x_ipsecrequest_len = size_req;
  2993. rq->sadb_x_ipsecrequest_proto = proto;
  2994. rq->sadb_x_ipsecrequest_mode = mode;
  2995. rq->sadb_x_ipsecrequest_level = level;
  2996. rq->sadb_x_ipsecrequest_reqid = reqid;
  2997. switch (family) {
  2998. case AF_INET:
  2999. sin = (struct sockaddr_in *)(rq + 1);
  3000. sin->sin_family = AF_INET;
  3001. memcpy(&sin->sin_addr.s_addr, src,
  3002. sizeof(sin->sin_addr.s_addr));
  3003. sin++;
  3004. sin->sin_family = AF_INET;
  3005. memcpy(&sin->sin_addr.s_addr, dst,
  3006. sizeof(sin->sin_addr.s_addr));
  3007. break;
  3008. #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
  3009. case AF_INET6:
  3010. sin6 = (struct sockaddr_in6 *)(rq + 1);
  3011. sin6->sin6_family = AF_INET6;
  3012. sin6->sin6_port = 0;
  3013. sin6->sin6_flowinfo = 0;
  3014. sin6->sin6_scope_id = 0;
  3015. memcpy(&sin6->sin6_addr.s6_addr, src,
  3016. sizeof(sin6->sin6_addr.s6_addr));
  3017. sin6++;
  3018. sin6->sin6_family = AF_INET6;
  3019. sin6->sin6_port = 0;
  3020. sin6->sin6_flowinfo = 0;
  3021. sin6->sin6_scope_id = 0;
  3022. memcpy(&sin6->sin6_addr.s6_addr, dst,
  3023. sizeof(sin6->sin6_addr.s6_addr));
  3024. break;
  3025. #endif
  3026. default:
  3027. return -EINVAL;
  3028. }
  3029. return 0;
  3030. }
  3031. #endif
  3032. #ifdef CONFIG_NET_KEY_MIGRATE
  3033. static int pfkey_send_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
  3034. struct xfrm_migrate *m, int num_bundles)
  3035. {
  3036. int i;
  3037. int sasize_sel;
  3038. int size = 0;
  3039. int size_pol = 0;
  3040. struct sk_buff *skb;
  3041. struct sadb_msg *hdr;
  3042. struct sadb_x_policy *pol;
  3043. struct xfrm_migrate *mp;
  3044. if (type != XFRM_POLICY_TYPE_MAIN)
  3045. return 0;
  3046. if (num_bundles <= 0 || num_bundles > XFRM_MAX_DEPTH)
  3047. return -EINVAL;
  3048. /* selector */
  3049. sasize_sel = pfkey_sockaddr_size(sel->family);
  3050. if (!sasize_sel)
  3051. return -EINVAL;
  3052. size += (sizeof(struct sadb_address) + sasize_sel) * 2;
  3053. /* policy info */
  3054. size_pol += sizeof(struct sadb_x_policy);
  3055. /* ipsecrequests */
  3056. for (i = 0, mp = m; i < num_bundles; i++, mp++) {
  3057. /* old locator pair */
  3058. size_pol += sizeof(struct sadb_x_ipsecrequest) +
  3059. pfkey_sockaddr_pair_size(mp->old_family);
  3060. /* new locator pair */
  3061. size_pol += sizeof(struct sadb_x_ipsecrequest) +
  3062. pfkey_sockaddr_pair_size(mp->new_family);
  3063. }
  3064. size += sizeof(struct sadb_msg) + size_pol;
  3065. /* alloc buffer */
  3066. skb = alloc_skb(size, GFP_ATOMIC);
  3067. if (skb == NULL)
  3068. return -ENOMEM;
  3069. hdr = (struct sadb_msg *)skb_put(skb, sizeof(struct sadb_msg));
  3070. hdr->sadb_msg_version = PF_KEY_V2;
  3071. hdr->sadb_msg_type = SADB_X_MIGRATE;
  3072. hdr->sadb_msg_satype = pfkey_proto2satype(m->proto);
  3073. hdr->sadb_msg_len = size / 8;
  3074. hdr->sadb_msg_errno = 0;
  3075. hdr->sadb_msg_reserved = 0;
  3076. hdr->sadb_msg_seq = 0;
  3077. hdr->sadb_msg_pid = 0;
  3078. /* selector src */
  3079. set_sadb_address(skb, sasize_sel, SADB_EXT_ADDRESS_SRC, sel);
  3080. /* selector dst */
  3081. set_sadb_address(skb, sasize_sel, SADB_EXT_ADDRESS_DST, sel);
  3082. /* policy information */
  3083. pol = (struct sadb_x_policy *)skb_put(skb, sizeof(struct sadb_x_policy));
  3084. pol->sadb_x_policy_len = size_pol / 8;
  3085. pol->sadb_x_policy_exttype = SADB_X_EXT_POLICY;
  3086. pol->sadb_x_policy_type = IPSEC_POLICY_IPSEC;
  3087. pol->sadb_x_policy_dir = dir + 1;
  3088. pol->sadb_x_policy_id = 0;
  3089. pol->sadb_x_policy_priority = 0;
  3090. for (i = 0, mp = m; i < num_bundles; i++, mp++) {
  3091. /* old ipsecrequest */
  3092. int mode = pfkey_mode_from_xfrm(mp->mode);
  3093. if (mode < 0)
  3094. return -EINVAL;
  3095. if (set_ipsecrequest(skb, mp->proto, mode,
  3096. (mp->reqid ? IPSEC_LEVEL_UNIQUE : IPSEC_LEVEL_REQUIRE),
  3097. mp->reqid, mp->old_family,
  3098. &mp->old_saddr, &mp->old_daddr) < 0) {
  3099. return -EINVAL;
  3100. }
  3101. /* new ipsecrequest */
  3102. if (set_ipsecrequest(skb, mp->proto, mode,
  3103. (mp->reqid ? IPSEC_LEVEL_UNIQUE : IPSEC_LEVEL_REQUIRE),
  3104. mp->reqid, mp->new_family,
  3105. &mp->new_saddr, &mp->new_daddr) < 0) {
  3106. return -EINVAL;
  3107. }
  3108. }
  3109. /* broadcast migrate message to sockets */
  3110. pfkey_broadcast(skb, GFP_ATOMIC, BROADCAST_ALL, NULL);
  3111. return 0;
  3112. }
  3113. #else
  3114. static int pfkey_send_migrate(struct xfrm_selector *sel, u8 dir, u8 type,
  3115. struct xfrm_migrate *m, int num_bundles)
  3116. {
  3117. return -ENOPROTOOPT;
  3118. }
  3119. #endif
  3120. static int pfkey_sendmsg(struct kiocb *kiocb,
  3121. struct socket *sock, struct msghdr *msg, size_t len)
  3122. {
  3123. struct sock *sk = sock->sk;
  3124. struct sk_buff *skb = NULL;
  3125. struct sadb_msg *hdr = NULL;
  3126. int err;
  3127. err = -EOPNOTSUPP;
  3128. if (msg->msg_flags & MSG_OOB)
  3129. goto out;
  3130. err = -EMSGSIZE;
  3131. if ((unsigned)len > sk->sk_sndbuf - 32)
  3132. goto out;
  3133. err = -ENOBUFS;
  3134. skb = alloc_skb(len, GFP_KERNEL);
  3135. if (skb == NULL)
  3136. goto out;
  3137. err = -EFAULT;
  3138. if (memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len))
  3139. goto out;
  3140. hdr = pfkey_get_base_msg(skb, &err);
  3141. if (!hdr)
  3142. goto out;
  3143. mutex_lock(&xfrm_cfg_mutex);
  3144. err = pfkey_process(sk, skb, hdr);
  3145. mutex_unlock(&xfrm_cfg_mutex);
  3146. out:
  3147. if (err && hdr && pfkey_error(hdr, err, sk) == 0)
  3148. err = 0;
  3149. if (skb)
  3150. kfree_skb(skb);
  3151. return err ? : len;
  3152. }
  3153. static int pfkey_recvmsg(struct kiocb *kiocb,
  3154. struct socket *sock, struct msghdr *msg, size_t len,
  3155. int flags)
  3156. {
  3157. struct sock *sk = sock->sk;
  3158. struct sk_buff *skb;
  3159. int copied, err;
  3160. err = -EINVAL;
  3161. if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
  3162. goto out;
  3163. msg->msg_namelen = 0;
  3164. skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err);
  3165. if (skb == NULL)
  3166. goto out;
  3167. copied = skb->len;
  3168. if (copied > len) {
  3169. msg->msg_flags |= MSG_TRUNC;
  3170. copied = len;
  3171. }
  3172. skb_reset_transport_header(skb);
  3173. err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
  3174. if (err)
  3175. goto out_free;
  3176. sock_recv_timestamp(msg, sk, skb);
  3177. err = (flags & MSG_TRUNC) ? skb->len : copied;
  3178. out_free:
  3179. skb_free_datagram(sk, skb);
  3180. out:
  3181. return err;
  3182. }
  3183. static const struct proto_ops pfkey_ops = {
  3184. .family = PF_KEY,
  3185. .owner = THIS_MODULE,
  3186. /* Operations that make no sense on pfkey sockets. */
  3187. .bind = sock_no_bind,
  3188. .connect = sock_no_connect,
  3189. .socketpair = sock_no_socketpair,
  3190. .accept = sock_no_accept,
  3191. .getname = sock_no_getname,
  3192. .ioctl = sock_no_ioctl,
  3193. .listen = sock_no_listen,
  3194. .shutdown = sock_no_shutdown,
  3195. .setsockopt = sock_no_setsockopt,
  3196. .getsockopt = sock_no_getsockopt,
  3197. .mmap = sock_no_mmap,
  3198. .sendpage = sock_no_sendpage,
  3199. /* Now the operations that really occur. */
  3200. .release = pfkey_release,
  3201. .poll = datagram_poll,
  3202. .sendmsg = pfkey_sendmsg,
  3203. .recvmsg = pfkey_recvmsg,
  3204. };
  3205. static struct net_proto_family pfkey_family_ops = {
  3206. .family = PF_KEY,
  3207. .create = pfkey_create,
  3208. .owner = THIS_MODULE,
  3209. };
  3210. #ifdef CONFIG_PROC_FS
  3211. static int pfkey_read_proc(char *buffer, char **start, off_t offset,
  3212. int length, int *eof, void *data)
  3213. {
  3214. off_t pos = 0;
  3215. off_t begin = 0;
  3216. int len = 0;
  3217. struct sock *s;
  3218. struct hlist_node *node;
  3219. len += sprintf(buffer,"sk RefCnt Rmem Wmem User Inode\n");
  3220. read_lock(&pfkey_table_lock);
  3221. sk_for_each(s, node, &pfkey_table) {
  3222. len += sprintf(buffer+len,"%p %-6d %-6u %-6u %-6u %-6lu",
  3223. s,
  3224. atomic_read(&s->sk_refcnt),
  3225. atomic_read(&s->sk_rmem_alloc),
  3226. atomic_read(&s->sk_wmem_alloc),
  3227. sock_i_uid(s),
  3228. sock_i_ino(s)
  3229. );
  3230. buffer[len++] = '\n';
  3231. pos = begin + len;
  3232. if (pos < offset) {
  3233. len = 0;
  3234. begin = pos;
  3235. }
  3236. if(pos > offset + length)
  3237. goto done;
  3238. }
  3239. *eof = 1;
  3240. done:
  3241. read_unlock(&pfkey_table_lock);
  3242. *start = buffer + (offset - begin);
  3243. len -= (offset - begin);
  3244. if (len > length)
  3245. len = length;
  3246. if (len < 0)
  3247. len = 0;
  3248. return len;
  3249. }
  3250. #endif
  3251. static struct xfrm_mgr pfkeyv2_mgr =
  3252. {
  3253. .id = "pfkeyv2",
  3254. .notify = pfkey_send_notify,
  3255. .acquire = pfkey_send_acquire,
  3256. .compile_policy = pfkey_compile_policy,
  3257. .new_mapping = pfkey_send_new_mapping,
  3258. .notify_policy = pfkey_send_policy_notify,
  3259. .migrate = pfkey_send_migrate,
  3260. };
  3261. static void __exit ipsec_pfkey_exit(void)
  3262. {
  3263. xfrm_unregister_km(&pfkeyv2_mgr);
  3264. remove_proc_entry("pfkey", init_net.proc_net);
  3265. sock_unregister(PF_KEY);
  3266. proto_unregister(&key_proto);
  3267. }
  3268. static int __init ipsec_pfkey_init(void)
  3269. {
  3270. int err = proto_register(&key_proto, 0);
  3271. if (err != 0)
  3272. goto out;
  3273. err = sock_register(&pfkey_family_ops);
  3274. if (err != 0)
  3275. goto out_unregister_key_proto;
  3276. #ifdef CONFIG_PROC_FS
  3277. err = -ENOMEM;
  3278. if (create_proc_read_entry("pfkey", 0, init_net.proc_net, pfkey_read_proc, NULL) == NULL)
  3279. goto out_sock_unregister;
  3280. #endif
  3281. err = xfrm_register_km(&pfkeyv2_mgr);
  3282. if (err != 0)
  3283. goto out_remove_proc_entry;
  3284. out:
  3285. return err;
  3286. out_remove_proc_entry:
  3287. #ifdef CONFIG_PROC_FS
  3288. remove_proc_entry("net/pfkey", NULL);
  3289. out_sock_unregister:
  3290. #endif
  3291. sock_unregister(PF_KEY);
  3292. out_unregister_key_proto:
  3293. proto_unregister(&key_proto);
  3294. goto out;
  3295. }
  3296. module_init(ipsec_pfkey_init);
  3297. module_exit(ipsec_pfkey_exit);
  3298. MODULE_LICENSE("GPL");
  3299. MODULE_ALIAS_NETPROTO(PF_KEY);