af_key.c 95 KB

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