af_key.c 101 KB

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