xfrm_state.c 62 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598
  1. /*
  2. * xfrm_state.c
  3. *
  4. * Changes:
  5. * Mitsuru KANDA @USAGI
  6. * Kazunori MIYAZAWA @USAGI
  7. * Kunihiro Ishiguro <kunihiro@ipinfusion.com>
  8. * IPv6 support
  9. * YOSHIFUJI Hideaki @USAGI
  10. * Split up af-specific functions
  11. * Derek Atkins <derek@ihtfp.com>
  12. * Add UDP Encapsulation
  13. *
  14. */
  15. #include <linux/workqueue.h>
  16. #include <net/xfrm.h>
  17. #include <linux/pfkeyv2.h>
  18. #include <linux/ipsec.h>
  19. #include <linux/module.h>
  20. #include <linux/cache.h>
  21. #include <linux/audit.h>
  22. #include <linux/uaccess.h>
  23. #include <linux/ktime.h>
  24. #include <linux/slab.h>
  25. #include <linux/interrupt.h>
  26. #include <linux/kernel.h>
  27. #include "xfrm_hash.h"
  28. #define xfrm_state_deref_prot(table, net) \
  29. rcu_dereference_protected((table), lockdep_is_held(&(net)->xfrm.xfrm_state_lock))
  30. static void xfrm_state_gc_task(struct work_struct *work);
  31. /* Each xfrm_state may be linked to two tables:
  32. 1. Hash table by (spi,daddr,ah/esp) to find SA by SPI. (input,ctl)
  33. 2. Hash table by (daddr,family,reqid) to find what SAs exist for given
  34. destination/tunnel endpoint. (output)
  35. */
  36. static unsigned int xfrm_state_hashmax __read_mostly = 1 * 1024 * 1024;
  37. static struct kmem_cache *xfrm_state_cache __ro_after_init;
  38. static DECLARE_WORK(xfrm_state_gc_work, xfrm_state_gc_task);
  39. static HLIST_HEAD(xfrm_state_gc_list);
  40. static inline bool xfrm_state_hold_rcu(struct xfrm_state __rcu *x)
  41. {
  42. return refcount_inc_not_zero(&x->refcnt);
  43. }
  44. static inline unsigned int xfrm_dst_hash(struct net *net,
  45. const xfrm_address_t *daddr,
  46. const xfrm_address_t *saddr,
  47. u32 reqid,
  48. unsigned short family)
  49. {
  50. return __xfrm_dst_hash(daddr, saddr, reqid, family, net->xfrm.state_hmask);
  51. }
  52. static inline unsigned int xfrm_src_hash(struct net *net,
  53. const xfrm_address_t *daddr,
  54. const xfrm_address_t *saddr,
  55. unsigned short family)
  56. {
  57. return __xfrm_src_hash(daddr, saddr, family, net->xfrm.state_hmask);
  58. }
  59. static inline unsigned int
  60. xfrm_spi_hash(struct net *net, const xfrm_address_t *daddr,
  61. __be32 spi, u8 proto, unsigned short family)
  62. {
  63. return __xfrm_spi_hash(daddr, spi, proto, family, net->xfrm.state_hmask);
  64. }
  65. static void xfrm_hash_transfer(struct hlist_head *list,
  66. struct hlist_head *ndsttable,
  67. struct hlist_head *nsrctable,
  68. struct hlist_head *nspitable,
  69. unsigned int nhashmask)
  70. {
  71. struct hlist_node *tmp;
  72. struct xfrm_state *x;
  73. hlist_for_each_entry_safe(x, tmp, list, bydst) {
  74. unsigned int h;
  75. h = __xfrm_dst_hash(&x->id.daddr, &x->props.saddr,
  76. x->props.reqid, x->props.family,
  77. nhashmask);
  78. hlist_add_head_rcu(&x->bydst, ndsttable + h);
  79. h = __xfrm_src_hash(&x->id.daddr, &x->props.saddr,
  80. x->props.family,
  81. nhashmask);
  82. hlist_add_head_rcu(&x->bysrc, nsrctable + h);
  83. if (x->id.spi) {
  84. h = __xfrm_spi_hash(&x->id.daddr, x->id.spi,
  85. x->id.proto, x->props.family,
  86. nhashmask);
  87. hlist_add_head_rcu(&x->byspi, nspitable + h);
  88. }
  89. }
  90. }
  91. static unsigned long xfrm_hash_new_size(unsigned int state_hmask)
  92. {
  93. return ((state_hmask + 1) << 1) * sizeof(struct hlist_head);
  94. }
  95. static void xfrm_hash_resize(struct work_struct *work)
  96. {
  97. struct net *net = container_of(work, struct net, xfrm.state_hash_work);
  98. struct hlist_head *ndst, *nsrc, *nspi, *odst, *osrc, *ospi;
  99. unsigned long nsize, osize;
  100. unsigned int nhashmask, ohashmask;
  101. int i;
  102. nsize = xfrm_hash_new_size(net->xfrm.state_hmask);
  103. ndst = xfrm_hash_alloc(nsize);
  104. if (!ndst)
  105. return;
  106. nsrc = xfrm_hash_alloc(nsize);
  107. if (!nsrc) {
  108. xfrm_hash_free(ndst, nsize);
  109. return;
  110. }
  111. nspi = xfrm_hash_alloc(nsize);
  112. if (!nspi) {
  113. xfrm_hash_free(ndst, nsize);
  114. xfrm_hash_free(nsrc, nsize);
  115. return;
  116. }
  117. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  118. write_seqcount_begin(&net->xfrm.xfrm_state_hash_generation);
  119. nhashmask = (nsize / sizeof(struct hlist_head)) - 1U;
  120. odst = xfrm_state_deref_prot(net->xfrm.state_bydst, net);
  121. for (i = net->xfrm.state_hmask; i >= 0; i--)
  122. xfrm_hash_transfer(odst + i, ndst, nsrc, nspi, nhashmask);
  123. osrc = xfrm_state_deref_prot(net->xfrm.state_bysrc, net);
  124. ospi = xfrm_state_deref_prot(net->xfrm.state_byspi, net);
  125. ohashmask = net->xfrm.state_hmask;
  126. rcu_assign_pointer(net->xfrm.state_bydst, ndst);
  127. rcu_assign_pointer(net->xfrm.state_bysrc, nsrc);
  128. rcu_assign_pointer(net->xfrm.state_byspi, nspi);
  129. net->xfrm.state_hmask = nhashmask;
  130. write_seqcount_end(&net->xfrm.xfrm_state_hash_generation);
  131. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  132. osize = (ohashmask + 1) * sizeof(struct hlist_head);
  133. synchronize_rcu();
  134. xfrm_hash_free(odst, osize);
  135. xfrm_hash_free(osrc, osize);
  136. xfrm_hash_free(ospi, osize);
  137. }
  138. static DEFINE_SPINLOCK(xfrm_state_afinfo_lock);
  139. static struct xfrm_state_afinfo __rcu *xfrm_state_afinfo[NPROTO];
  140. static DEFINE_SPINLOCK(xfrm_state_gc_lock);
  141. int __xfrm_state_delete(struct xfrm_state *x);
  142. int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol);
  143. bool km_is_alive(const struct km_event *c);
  144. void km_state_expired(struct xfrm_state *x, int hard, u32 portid);
  145. static DEFINE_SPINLOCK(xfrm_type_lock);
  146. int xfrm_register_type(const struct xfrm_type *type, unsigned short family)
  147. {
  148. struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
  149. const struct xfrm_type **typemap;
  150. int err = 0;
  151. if (unlikely(afinfo == NULL))
  152. return -EAFNOSUPPORT;
  153. typemap = afinfo->type_map;
  154. spin_lock_bh(&xfrm_type_lock);
  155. if (likely(typemap[type->proto] == NULL))
  156. typemap[type->proto] = type;
  157. else
  158. err = -EEXIST;
  159. spin_unlock_bh(&xfrm_type_lock);
  160. rcu_read_unlock();
  161. return err;
  162. }
  163. EXPORT_SYMBOL(xfrm_register_type);
  164. int xfrm_unregister_type(const struct xfrm_type *type, unsigned short family)
  165. {
  166. struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
  167. const struct xfrm_type **typemap;
  168. int err = 0;
  169. if (unlikely(afinfo == NULL))
  170. return -EAFNOSUPPORT;
  171. typemap = afinfo->type_map;
  172. spin_lock_bh(&xfrm_type_lock);
  173. if (unlikely(typemap[type->proto] != type))
  174. err = -ENOENT;
  175. else
  176. typemap[type->proto] = NULL;
  177. spin_unlock_bh(&xfrm_type_lock);
  178. rcu_read_unlock();
  179. return err;
  180. }
  181. EXPORT_SYMBOL(xfrm_unregister_type);
  182. static const struct xfrm_type *xfrm_get_type(u8 proto, unsigned short family)
  183. {
  184. struct xfrm_state_afinfo *afinfo;
  185. const struct xfrm_type **typemap;
  186. const struct xfrm_type *type;
  187. int modload_attempted = 0;
  188. retry:
  189. afinfo = xfrm_state_get_afinfo(family);
  190. if (unlikely(afinfo == NULL))
  191. return NULL;
  192. typemap = afinfo->type_map;
  193. type = READ_ONCE(typemap[proto]);
  194. if (unlikely(type && !try_module_get(type->owner)))
  195. type = NULL;
  196. rcu_read_unlock();
  197. if (!type && !modload_attempted) {
  198. request_module("xfrm-type-%d-%d", family, proto);
  199. modload_attempted = 1;
  200. goto retry;
  201. }
  202. return type;
  203. }
  204. static void xfrm_put_type(const struct xfrm_type *type)
  205. {
  206. module_put(type->owner);
  207. }
  208. static DEFINE_SPINLOCK(xfrm_type_offload_lock);
  209. int xfrm_register_type_offload(const struct xfrm_type_offload *type,
  210. unsigned short family)
  211. {
  212. struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
  213. const struct xfrm_type_offload **typemap;
  214. int err = 0;
  215. if (unlikely(afinfo == NULL))
  216. return -EAFNOSUPPORT;
  217. typemap = afinfo->type_offload_map;
  218. spin_lock_bh(&xfrm_type_offload_lock);
  219. if (likely(typemap[type->proto] == NULL))
  220. typemap[type->proto] = type;
  221. else
  222. err = -EEXIST;
  223. spin_unlock_bh(&xfrm_type_offload_lock);
  224. rcu_read_unlock();
  225. return err;
  226. }
  227. EXPORT_SYMBOL(xfrm_register_type_offload);
  228. int xfrm_unregister_type_offload(const struct xfrm_type_offload *type,
  229. unsigned short family)
  230. {
  231. struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
  232. const struct xfrm_type_offload **typemap;
  233. int err = 0;
  234. if (unlikely(afinfo == NULL))
  235. return -EAFNOSUPPORT;
  236. typemap = afinfo->type_offload_map;
  237. spin_lock_bh(&xfrm_type_offload_lock);
  238. if (unlikely(typemap[type->proto] != type))
  239. err = -ENOENT;
  240. else
  241. typemap[type->proto] = NULL;
  242. spin_unlock_bh(&xfrm_type_offload_lock);
  243. rcu_read_unlock();
  244. return err;
  245. }
  246. EXPORT_SYMBOL(xfrm_unregister_type_offload);
  247. static const struct xfrm_type_offload *
  248. xfrm_get_type_offload(u8 proto, unsigned short family, bool try_load)
  249. {
  250. struct xfrm_state_afinfo *afinfo;
  251. const struct xfrm_type_offload **typemap;
  252. const struct xfrm_type_offload *type;
  253. retry:
  254. afinfo = xfrm_state_get_afinfo(family);
  255. if (unlikely(afinfo == NULL))
  256. return NULL;
  257. typemap = afinfo->type_offload_map;
  258. type = typemap[proto];
  259. if ((type && !try_module_get(type->owner)))
  260. type = NULL;
  261. rcu_read_unlock();
  262. if (!type && try_load) {
  263. request_module("xfrm-offload-%d-%d", family, proto);
  264. try_load = false;
  265. goto retry;
  266. }
  267. return type;
  268. }
  269. static void xfrm_put_type_offload(const struct xfrm_type_offload *type)
  270. {
  271. module_put(type->owner);
  272. }
  273. static DEFINE_SPINLOCK(xfrm_mode_lock);
  274. int xfrm_register_mode(struct xfrm_mode *mode, int family)
  275. {
  276. struct xfrm_state_afinfo *afinfo;
  277. struct xfrm_mode **modemap;
  278. int err;
  279. if (unlikely(mode->encap >= XFRM_MODE_MAX))
  280. return -EINVAL;
  281. afinfo = xfrm_state_get_afinfo(family);
  282. if (unlikely(afinfo == NULL))
  283. return -EAFNOSUPPORT;
  284. err = -EEXIST;
  285. modemap = afinfo->mode_map;
  286. spin_lock_bh(&xfrm_mode_lock);
  287. if (modemap[mode->encap])
  288. goto out;
  289. err = -ENOENT;
  290. if (!try_module_get(afinfo->owner))
  291. goto out;
  292. mode->afinfo = afinfo;
  293. modemap[mode->encap] = mode;
  294. err = 0;
  295. out:
  296. spin_unlock_bh(&xfrm_mode_lock);
  297. rcu_read_unlock();
  298. return err;
  299. }
  300. EXPORT_SYMBOL(xfrm_register_mode);
  301. int xfrm_unregister_mode(struct xfrm_mode *mode, int family)
  302. {
  303. struct xfrm_state_afinfo *afinfo;
  304. struct xfrm_mode **modemap;
  305. int err;
  306. if (unlikely(mode->encap >= XFRM_MODE_MAX))
  307. return -EINVAL;
  308. afinfo = xfrm_state_get_afinfo(family);
  309. if (unlikely(afinfo == NULL))
  310. return -EAFNOSUPPORT;
  311. err = -ENOENT;
  312. modemap = afinfo->mode_map;
  313. spin_lock_bh(&xfrm_mode_lock);
  314. if (likely(modemap[mode->encap] == mode)) {
  315. modemap[mode->encap] = NULL;
  316. module_put(mode->afinfo->owner);
  317. err = 0;
  318. }
  319. spin_unlock_bh(&xfrm_mode_lock);
  320. rcu_read_unlock();
  321. return err;
  322. }
  323. EXPORT_SYMBOL(xfrm_unregister_mode);
  324. static struct xfrm_mode *xfrm_get_mode(unsigned int encap, int family)
  325. {
  326. struct xfrm_state_afinfo *afinfo;
  327. struct xfrm_mode *mode;
  328. int modload_attempted = 0;
  329. if (unlikely(encap >= XFRM_MODE_MAX))
  330. return NULL;
  331. retry:
  332. afinfo = xfrm_state_get_afinfo(family);
  333. if (unlikely(afinfo == NULL))
  334. return NULL;
  335. mode = READ_ONCE(afinfo->mode_map[encap]);
  336. if (unlikely(mode && !try_module_get(mode->owner)))
  337. mode = NULL;
  338. rcu_read_unlock();
  339. if (!mode && !modload_attempted) {
  340. request_module("xfrm-mode-%d-%d", family, encap);
  341. modload_attempted = 1;
  342. goto retry;
  343. }
  344. return mode;
  345. }
  346. static void xfrm_put_mode(struct xfrm_mode *mode)
  347. {
  348. module_put(mode->owner);
  349. }
  350. void xfrm_state_free(struct xfrm_state *x)
  351. {
  352. kmem_cache_free(xfrm_state_cache, x);
  353. }
  354. EXPORT_SYMBOL(xfrm_state_free);
  355. static void ___xfrm_state_destroy(struct xfrm_state *x)
  356. {
  357. tasklet_hrtimer_cancel(&x->mtimer);
  358. del_timer_sync(&x->rtimer);
  359. kfree(x->aead);
  360. kfree(x->aalg);
  361. kfree(x->ealg);
  362. kfree(x->calg);
  363. kfree(x->encap);
  364. kfree(x->coaddr);
  365. kfree(x->replay_esn);
  366. kfree(x->preplay_esn);
  367. if (x->inner_mode)
  368. xfrm_put_mode(x->inner_mode);
  369. if (x->inner_mode_iaf)
  370. xfrm_put_mode(x->inner_mode_iaf);
  371. if (x->outer_mode)
  372. xfrm_put_mode(x->outer_mode);
  373. if (x->type_offload)
  374. xfrm_put_type_offload(x->type_offload);
  375. if (x->type) {
  376. x->type->destructor(x);
  377. xfrm_put_type(x->type);
  378. }
  379. if (x->xfrag.page)
  380. put_page(x->xfrag.page);
  381. xfrm_dev_state_free(x);
  382. security_xfrm_state_free(x);
  383. xfrm_state_free(x);
  384. }
  385. static void xfrm_state_gc_task(struct work_struct *work)
  386. {
  387. struct xfrm_state *x;
  388. struct hlist_node *tmp;
  389. struct hlist_head gc_list;
  390. spin_lock_bh(&xfrm_state_gc_lock);
  391. hlist_move_list(&xfrm_state_gc_list, &gc_list);
  392. spin_unlock_bh(&xfrm_state_gc_lock);
  393. synchronize_rcu();
  394. hlist_for_each_entry_safe(x, tmp, &gc_list, gclist)
  395. ___xfrm_state_destroy(x);
  396. }
  397. static enum hrtimer_restart xfrm_timer_handler(struct hrtimer *me)
  398. {
  399. struct tasklet_hrtimer *thr = container_of(me, struct tasklet_hrtimer, timer);
  400. struct xfrm_state *x = container_of(thr, struct xfrm_state, mtimer);
  401. time64_t now = ktime_get_real_seconds();
  402. time64_t next = TIME64_MAX;
  403. int warn = 0;
  404. int err = 0;
  405. spin_lock(&x->lock);
  406. if (x->km.state == XFRM_STATE_DEAD)
  407. goto out;
  408. if (x->km.state == XFRM_STATE_EXPIRED)
  409. goto expired;
  410. if (x->lft.hard_add_expires_seconds) {
  411. long tmo = x->lft.hard_add_expires_seconds +
  412. x->curlft.add_time - now;
  413. if (tmo <= 0) {
  414. if (x->xflags & XFRM_SOFT_EXPIRE) {
  415. /* enter hard expire without soft expire first?!
  416. * setting a new date could trigger this.
  417. * workaround: fix x->curflt.add_time by below:
  418. */
  419. x->curlft.add_time = now - x->saved_tmo - 1;
  420. tmo = x->lft.hard_add_expires_seconds - x->saved_tmo;
  421. } else
  422. goto expired;
  423. }
  424. if (tmo < next)
  425. next = tmo;
  426. }
  427. if (x->lft.hard_use_expires_seconds) {
  428. long tmo = x->lft.hard_use_expires_seconds +
  429. (x->curlft.use_time ? : now) - now;
  430. if (tmo <= 0)
  431. goto expired;
  432. if (tmo < next)
  433. next = tmo;
  434. }
  435. if (x->km.dying)
  436. goto resched;
  437. if (x->lft.soft_add_expires_seconds) {
  438. long tmo = x->lft.soft_add_expires_seconds +
  439. x->curlft.add_time - now;
  440. if (tmo <= 0) {
  441. warn = 1;
  442. x->xflags &= ~XFRM_SOFT_EXPIRE;
  443. } else if (tmo < next) {
  444. next = tmo;
  445. x->xflags |= XFRM_SOFT_EXPIRE;
  446. x->saved_tmo = tmo;
  447. }
  448. }
  449. if (x->lft.soft_use_expires_seconds) {
  450. long tmo = x->lft.soft_use_expires_seconds +
  451. (x->curlft.use_time ? : now) - now;
  452. if (tmo <= 0)
  453. warn = 1;
  454. else if (tmo < next)
  455. next = tmo;
  456. }
  457. x->km.dying = warn;
  458. if (warn)
  459. km_state_expired(x, 0, 0);
  460. resched:
  461. if (next != TIME64_MAX) {
  462. tasklet_hrtimer_start(&x->mtimer, ktime_set(next, 0), HRTIMER_MODE_REL);
  463. }
  464. goto out;
  465. expired:
  466. if (x->km.state == XFRM_STATE_ACQ && x->id.spi == 0)
  467. x->km.state = XFRM_STATE_EXPIRED;
  468. err = __xfrm_state_delete(x);
  469. if (!err)
  470. km_state_expired(x, 1, 0);
  471. xfrm_audit_state_delete(x, err ? 0 : 1, true);
  472. out:
  473. spin_unlock(&x->lock);
  474. return HRTIMER_NORESTART;
  475. }
  476. static void xfrm_replay_timer_handler(struct timer_list *t);
  477. struct xfrm_state *xfrm_state_alloc(struct net *net)
  478. {
  479. struct xfrm_state *x;
  480. x = kmem_cache_alloc(xfrm_state_cache, GFP_ATOMIC | __GFP_ZERO);
  481. if (x) {
  482. write_pnet(&x->xs_net, net);
  483. refcount_set(&x->refcnt, 1);
  484. atomic_set(&x->tunnel_users, 0);
  485. INIT_LIST_HEAD(&x->km.all);
  486. INIT_HLIST_NODE(&x->bydst);
  487. INIT_HLIST_NODE(&x->bysrc);
  488. INIT_HLIST_NODE(&x->byspi);
  489. tasklet_hrtimer_init(&x->mtimer, xfrm_timer_handler,
  490. CLOCK_BOOTTIME, HRTIMER_MODE_ABS);
  491. timer_setup(&x->rtimer, xfrm_replay_timer_handler, 0);
  492. x->curlft.add_time = ktime_get_real_seconds();
  493. x->lft.soft_byte_limit = XFRM_INF;
  494. x->lft.soft_packet_limit = XFRM_INF;
  495. x->lft.hard_byte_limit = XFRM_INF;
  496. x->lft.hard_packet_limit = XFRM_INF;
  497. x->replay_maxage = 0;
  498. x->replay_maxdiff = 0;
  499. x->inner_mode = NULL;
  500. x->inner_mode_iaf = NULL;
  501. spin_lock_init(&x->lock);
  502. }
  503. return x;
  504. }
  505. EXPORT_SYMBOL(xfrm_state_alloc);
  506. void __xfrm_state_destroy(struct xfrm_state *x, bool sync)
  507. {
  508. WARN_ON(x->km.state != XFRM_STATE_DEAD);
  509. if (sync) {
  510. synchronize_rcu();
  511. ___xfrm_state_destroy(x);
  512. } else {
  513. spin_lock_bh(&xfrm_state_gc_lock);
  514. hlist_add_head(&x->gclist, &xfrm_state_gc_list);
  515. spin_unlock_bh(&xfrm_state_gc_lock);
  516. schedule_work(&xfrm_state_gc_work);
  517. }
  518. }
  519. EXPORT_SYMBOL(__xfrm_state_destroy);
  520. int __xfrm_state_delete(struct xfrm_state *x)
  521. {
  522. struct net *net = xs_net(x);
  523. int err = -ESRCH;
  524. if (x->km.state != XFRM_STATE_DEAD) {
  525. x->km.state = XFRM_STATE_DEAD;
  526. spin_lock(&net->xfrm.xfrm_state_lock);
  527. list_del(&x->km.all);
  528. hlist_del_rcu(&x->bydst);
  529. hlist_del_rcu(&x->bysrc);
  530. if (x->id.spi)
  531. hlist_del_rcu(&x->byspi);
  532. net->xfrm.state_num--;
  533. spin_unlock(&net->xfrm.xfrm_state_lock);
  534. xfrm_dev_state_delete(x);
  535. /* All xfrm_state objects are created by xfrm_state_alloc.
  536. * The xfrm_state_alloc call gives a reference, and that
  537. * is what we are dropping here.
  538. */
  539. xfrm_state_put(x);
  540. err = 0;
  541. }
  542. return err;
  543. }
  544. EXPORT_SYMBOL(__xfrm_state_delete);
  545. int xfrm_state_delete(struct xfrm_state *x)
  546. {
  547. int err;
  548. spin_lock_bh(&x->lock);
  549. err = __xfrm_state_delete(x);
  550. spin_unlock_bh(&x->lock);
  551. return err;
  552. }
  553. EXPORT_SYMBOL(xfrm_state_delete);
  554. #ifdef CONFIG_SECURITY_NETWORK_XFRM
  555. static inline int
  556. xfrm_state_flush_secctx_check(struct net *net, u8 proto, bool task_valid)
  557. {
  558. int i, err = 0;
  559. for (i = 0; i <= net->xfrm.state_hmask; i++) {
  560. struct xfrm_state *x;
  561. hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
  562. if (xfrm_id_proto_match(x->id.proto, proto) &&
  563. (err = security_xfrm_state_delete(x)) != 0) {
  564. xfrm_audit_state_delete(x, 0, task_valid);
  565. return err;
  566. }
  567. }
  568. }
  569. return err;
  570. }
  571. static inline int
  572. xfrm_dev_state_flush_secctx_check(struct net *net, struct net_device *dev, bool task_valid)
  573. {
  574. int i, err = 0;
  575. for (i = 0; i <= net->xfrm.state_hmask; i++) {
  576. struct xfrm_state *x;
  577. struct xfrm_state_offload *xso;
  578. hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
  579. xso = &x->xso;
  580. if (xso->dev == dev &&
  581. (err = security_xfrm_state_delete(x)) != 0) {
  582. xfrm_audit_state_delete(x, 0, task_valid);
  583. return err;
  584. }
  585. }
  586. }
  587. return err;
  588. }
  589. #else
  590. static inline int
  591. xfrm_state_flush_secctx_check(struct net *net, u8 proto, bool task_valid)
  592. {
  593. return 0;
  594. }
  595. static inline int
  596. xfrm_dev_state_flush_secctx_check(struct net *net, struct net_device *dev, bool task_valid)
  597. {
  598. return 0;
  599. }
  600. #endif
  601. int xfrm_state_flush(struct net *net, u8 proto, bool task_valid, bool sync)
  602. {
  603. int i, err = 0, cnt = 0;
  604. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  605. err = xfrm_state_flush_secctx_check(net, proto, task_valid);
  606. if (err)
  607. goto out;
  608. err = -ESRCH;
  609. for (i = 0; i <= net->xfrm.state_hmask; i++) {
  610. struct xfrm_state *x;
  611. restart:
  612. hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
  613. if (!xfrm_state_kern(x) &&
  614. xfrm_id_proto_match(x->id.proto, proto)) {
  615. xfrm_state_hold(x);
  616. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  617. err = xfrm_state_delete(x);
  618. xfrm_audit_state_delete(x, err ? 0 : 1,
  619. task_valid);
  620. if (sync)
  621. xfrm_state_put_sync(x);
  622. else
  623. xfrm_state_put(x);
  624. if (!err)
  625. cnt++;
  626. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  627. goto restart;
  628. }
  629. }
  630. }
  631. out:
  632. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  633. if (cnt)
  634. err = 0;
  635. return err;
  636. }
  637. EXPORT_SYMBOL(xfrm_state_flush);
  638. int xfrm_dev_state_flush(struct net *net, struct net_device *dev, bool task_valid)
  639. {
  640. int i, err = 0, cnt = 0;
  641. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  642. err = xfrm_dev_state_flush_secctx_check(net, dev, task_valid);
  643. if (err)
  644. goto out;
  645. err = -ESRCH;
  646. for (i = 0; i <= net->xfrm.state_hmask; i++) {
  647. struct xfrm_state *x;
  648. struct xfrm_state_offload *xso;
  649. restart:
  650. hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
  651. xso = &x->xso;
  652. if (!xfrm_state_kern(x) && xso->dev == dev) {
  653. xfrm_state_hold(x);
  654. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  655. err = xfrm_state_delete(x);
  656. xfrm_audit_state_delete(x, err ? 0 : 1,
  657. task_valid);
  658. xfrm_state_put(x);
  659. if (!err)
  660. cnt++;
  661. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  662. goto restart;
  663. }
  664. }
  665. }
  666. if (cnt)
  667. err = 0;
  668. out:
  669. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  670. return err;
  671. }
  672. EXPORT_SYMBOL(xfrm_dev_state_flush);
  673. void xfrm_sad_getinfo(struct net *net, struct xfrmk_sadinfo *si)
  674. {
  675. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  676. si->sadcnt = net->xfrm.state_num;
  677. si->sadhcnt = net->xfrm.state_hmask + 1;
  678. si->sadhmcnt = xfrm_state_hashmax;
  679. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  680. }
  681. EXPORT_SYMBOL(xfrm_sad_getinfo);
  682. static void
  683. xfrm_init_tempstate(struct xfrm_state *x, const struct flowi *fl,
  684. const struct xfrm_tmpl *tmpl,
  685. const xfrm_address_t *daddr, const xfrm_address_t *saddr,
  686. unsigned short family)
  687. {
  688. struct xfrm_state_afinfo *afinfo = xfrm_state_afinfo_get_rcu(family);
  689. if (!afinfo)
  690. return;
  691. afinfo->init_tempsel(&x->sel, fl);
  692. if (family != tmpl->encap_family) {
  693. afinfo = xfrm_state_afinfo_get_rcu(tmpl->encap_family);
  694. if (!afinfo)
  695. return;
  696. }
  697. afinfo->init_temprop(x, tmpl, daddr, saddr);
  698. }
  699. static struct xfrm_state *__xfrm_state_lookup(struct net *net, u32 mark,
  700. const xfrm_address_t *daddr,
  701. __be32 spi, u8 proto,
  702. unsigned short family)
  703. {
  704. unsigned int h = xfrm_spi_hash(net, daddr, spi, proto, family);
  705. struct xfrm_state *x;
  706. hlist_for_each_entry_rcu(x, net->xfrm.state_byspi + h, byspi) {
  707. if (x->props.family != family ||
  708. x->id.spi != spi ||
  709. x->id.proto != proto ||
  710. !xfrm_addr_equal(&x->id.daddr, daddr, family))
  711. continue;
  712. if ((mark & x->mark.m) != x->mark.v)
  713. continue;
  714. if (!xfrm_state_hold_rcu(x))
  715. continue;
  716. return x;
  717. }
  718. return NULL;
  719. }
  720. static struct xfrm_state *__xfrm_state_lookup_byaddr(struct net *net, u32 mark,
  721. const xfrm_address_t *daddr,
  722. const xfrm_address_t *saddr,
  723. u8 proto, unsigned short family)
  724. {
  725. unsigned int h = xfrm_src_hash(net, daddr, saddr, family);
  726. struct xfrm_state *x;
  727. hlist_for_each_entry_rcu(x, net->xfrm.state_bysrc + h, bysrc) {
  728. if (x->props.family != family ||
  729. x->id.proto != proto ||
  730. !xfrm_addr_equal(&x->id.daddr, daddr, family) ||
  731. !xfrm_addr_equal(&x->props.saddr, saddr, family))
  732. continue;
  733. if ((mark & x->mark.m) != x->mark.v)
  734. continue;
  735. if (!xfrm_state_hold_rcu(x))
  736. continue;
  737. return x;
  738. }
  739. return NULL;
  740. }
  741. static inline struct xfrm_state *
  742. __xfrm_state_locate(struct xfrm_state *x, int use_spi, int family)
  743. {
  744. struct net *net = xs_net(x);
  745. u32 mark = x->mark.v & x->mark.m;
  746. if (use_spi)
  747. return __xfrm_state_lookup(net, mark, &x->id.daddr,
  748. x->id.spi, x->id.proto, family);
  749. else
  750. return __xfrm_state_lookup_byaddr(net, mark,
  751. &x->id.daddr,
  752. &x->props.saddr,
  753. x->id.proto, family);
  754. }
  755. static void xfrm_hash_grow_check(struct net *net, int have_hash_collision)
  756. {
  757. if (have_hash_collision &&
  758. (net->xfrm.state_hmask + 1) < xfrm_state_hashmax &&
  759. net->xfrm.state_num > net->xfrm.state_hmask)
  760. schedule_work(&net->xfrm.state_hash_work);
  761. }
  762. static void xfrm_state_look_at(struct xfrm_policy *pol, struct xfrm_state *x,
  763. const struct flowi *fl, unsigned short family,
  764. struct xfrm_state **best, int *acq_in_progress,
  765. int *error)
  766. {
  767. /* Resolution logic:
  768. * 1. There is a valid state with matching selector. Done.
  769. * 2. Valid state with inappropriate selector. Skip.
  770. *
  771. * Entering area of "sysdeps".
  772. *
  773. * 3. If state is not valid, selector is temporary, it selects
  774. * only session which triggered previous resolution. Key
  775. * manager will do something to install a state with proper
  776. * selector.
  777. */
  778. if (x->km.state == XFRM_STATE_VALID) {
  779. if ((x->sel.family &&
  780. (x->sel.family != family ||
  781. !xfrm_selector_match(&x->sel, fl, family))) ||
  782. !security_xfrm_state_pol_flow_match(x, pol, fl))
  783. return;
  784. if (!*best ||
  785. (*best)->km.dying > x->km.dying ||
  786. ((*best)->km.dying == x->km.dying &&
  787. (*best)->curlft.add_time < x->curlft.add_time))
  788. *best = x;
  789. } else if (x->km.state == XFRM_STATE_ACQ) {
  790. *acq_in_progress = 1;
  791. } else if (x->km.state == XFRM_STATE_ERROR ||
  792. x->km.state == XFRM_STATE_EXPIRED) {
  793. if ((!x->sel.family ||
  794. (x->sel.family == family &&
  795. xfrm_selector_match(&x->sel, fl, family))) &&
  796. security_xfrm_state_pol_flow_match(x, pol, fl))
  797. *error = -ESRCH;
  798. }
  799. }
  800. struct xfrm_state *
  801. xfrm_state_find(const xfrm_address_t *daddr, const xfrm_address_t *saddr,
  802. const struct flowi *fl, struct xfrm_tmpl *tmpl,
  803. struct xfrm_policy *pol, int *err,
  804. unsigned short family, u32 if_id)
  805. {
  806. static xfrm_address_t saddr_wildcard = { };
  807. struct net *net = xp_net(pol);
  808. unsigned int h, h_wildcard;
  809. struct xfrm_state *x, *x0, *to_put;
  810. int acquire_in_progress = 0;
  811. int error = 0;
  812. struct xfrm_state *best = NULL;
  813. u32 mark = pol->mark.v & pol->mark.m;
  814. unsigned short encap_family = tmpl->encap_family;
  815. unsigned int sequence;
  816. struct km_event c;
  817. to_put = NULL;
  818. sequence = read_seqcount_begin(&net->xfrm.xfrm_state_hash_generation);
  819. rcu_read_lock();
  820. h = xfrm_dst_hash(net, daddr, saddr, tmpl->reqid, encap_family);
  821. hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h, bydst) {
  822. if (x->props.family == encap_family &&
  823. x->props.reqid == tmpl->reqid &&
  824. (mark & x->mark.m) == x->mark.v &&
  825. x->if_id == if_id &&
  826. !(x->props.flags & XFRM_STATE_WILDRECV) &&
  827. xfrm_state_addr_check(x, daddr, saddr, encap_family) &&
  828. tmpl->mode == x->props.mode &&
  829. tmpl->id.proto == x->id.proto &&
  830. (tmpl->id.spi == x->id.spi || !tmpl->id.spi))
  831. xfrm_state_look_at(pol, x, fl, family,
  832. &best, &acquire_in_progress, &error);
  833. }
  834. if (best || acquire_in_progress)
  835. goto found;
  836. h_wildcard = xfrm_dst_hash(net, daddr, &saddr_wildcard, tmpl->reqid, encap_family);
  837. hlist_for_each_entry_rcu(x, net->xfrm.state_bydst + h_wildcard, bydst) {
  838. if (x->props.family == encap_family &&
  839. x->props.reqid == tmpl->reqid &&
  840. (mark & x->mark.m) == x->mark.v &&
  841. x->if_id == if_id &&
  842. !(x->props.flags & XFRM_STATE_WILDRECV) &&
  843. xfrm_addr_equal(&x->id.daddr, daddr, encap_family) &&
  844. tmpl->mode == x->props.mode &&
  845. tmpl->id.proto == x->id.proto &&
  846. (tmpl->id.spi == x->id.spi || !tmpl->id.spi))
  847. xfrm_state_look_at(pol, x, fl, family,
  848. &best, &acquire_in_progress, &error);
  849. }
  850. found:
  851. x = best;
  852. if (!x && !error && !acquire_in_progress) {
  853. if (tmpl->id.spi &&
  854. (x0 = __xfrm_state_lookup(net, mark, daddr, tmpl->id.spi,
  855. tmpl->id.proto, encap_family)) != NULL) {
  856. to_put = x0;
  857. error = -EEXIST;
  858. goto out;
  859. }
  860. c.net = net;
  861. /* If the KMs have no listeners (yet...), avoid allocating an SA
  862. * for each and every packet - garbage collection might not
  863. * handle the flood.
  864. */
  865. if (!km_is_alive(&c)) {
  866. error = -ESRCH;
  867. goto out;
  868. }
  869. x = xfrm_state_alloc(net);
  870. if (x == NULL) {
  871. error = -ENOMEM;
  872. goto out;
  873. }
  874. /* Initialize temporary state matching only
  875. * to current session. */
  876. xfrm_init_tempstate(x, fl, tmpl, daddr, saddr, family);
  877. memcpy(&x->mark, &pol->mark, sizeof(x->mark));
  878. x->if_id = if_id;
  879. error = security_xfrm_state_alloc_acquire(x, pol->security, fl->flowi_secid);
  880. if (error) {
  881. x->km.state = XFRM_STATE_DEAD;
  882. to_put = x;
  883. x = NULL;
  884. goto out;
  885. }
  886. if (km_query(x, tmpl, pol) == 0) {
  887. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  888. x->km.state = XFRM_STATE_ACQ;
  889. list_add(&x->km.all, &net->xfrm.state_all);
  890. hlist_add_head_rcu(&x->bydst, net->xfrm.state_bydst + h);
  891. h = xfrm_src_hash(net, daddr, saddr, encap_family);
  892. hlist_add_head_rcu(&x->bysrc, net->xfrm.state_bysrc + h);
  893. if (x->id.spi) {
  894. h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, encap_family);
  895. hlist_add_head_rcu(&x->byspi, net->xfrm.state_byspi + h);
  896. }
  897. x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires;
  898. tasklet_hrtimer_start(&x->mtimer, ktime_set(net->xfrm.sysctl_acq_expires, 0), HRTIMER_MODE_REL);
  899. net->xfrm.state_num++;
  900. xfrm_hash_grow_check(net, x->bydst.next != NULL);
  901. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  902. } else {
  903. x->km.state = XFRM_STATE_DEAD;
  904. to_put = x;
  905. x = NULL;
  906. error = -ESRCH;
  907. }
  908. }
  909. out:
  910. if (x) {
  911. if (!xfrm_state_hold_rcu(x)) {
  912. *err = -EAGAIN;
  913. x = NULL;
  914. }
  915. } else {
  916. *err = acquire_in_progress ? -EAGAIN : error;
  917. }
  918. rcu_read_unlock();
  919. if (to_put)
  920. xfrm_state_put(to_put);
  921. if (read_seqcount_retry(&net->xfrm.xfrm_state_hash_generation, sequence)) {
  922. *err = -EAGAIN;
  923. if (x) {
  924. xfrm_state_put(x);
  925. x = NULL;
  926. }
  927. }
  928. return x;
  929. }
  930. struct xfrm_state *
  931. xfrm_stateonly_find(struct net *net, u32 mark, u32 if_id,
  932. xfrm_address_t *daddr, xfrm_address_t *saddr,
  933. unsigned short family, u8 mode, u8 proto, u32 reqid)
  934. {
  935. unsigned int h;
  936. struct xfrm_state *rx = NULL, *x = NULL;
  937. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  938. h = xfrm_dst_hash(net, daddr, saddr, reqid, family);
  939. hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
  940. if (x->props.family == family &&
  941. x->props.reqid == reqid &&
  942. (mark & x->mark.m) == x->mark.v &&
  943. x->if_id == if_id &&
  944. !(x->props.flags & XFRM_STATE_WILDRECV) &&
  945. xfrm_state_addr_check(x, daddr, saddr, family) &&
  946. mode == x->props.mode &&
  947. proto == x->id.proto &&
  948. x->km.state == XFRM_STATE_VALID) {
  949. rx = x;
  950. break;
  951. }
  952. }
  953. if (rx)
  954. xfrm_state_hold(rx);
  955. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  956. return rx;
  957. }
  958. EXPORT_SYMBOL(xfrm_stateonly_find);
  959. struct xfrm_state *xfrm_state_lookup_byspi(struct net *net, __be32 spi,
  960. unsigned short family)
  961. {
  962. struct xfrm_state *x;
  963. struct xfrm_state_walk *w;
  964. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  965. list_for_each_entry(w, &net->xfrm.state_all, all) {
  966. x = container_of(w, struct xfrm_state, km);
  967. if (x->props.family != family ||
  968. x->id.spi != spi)
  969. continue;
  970. xfrm_state_hold(x);
  971. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  972. return x;
  973. }
  974. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  975. return NULL;
  976. }
  977. EXPORT_SYMBOL(xfrm_state_lookup_byspi);
  978. static void __xfrm_state_insert(struct xfrm_state *x)
  979. {
  980. struct net *net = xs_net(x);
  981. unsigned int h;
  982. list_add(&x->km.all, &net->xfrm.state_all);
  983. h = xfrm_dst_hash(net, &x->id.daddr, &x->props.saddr,
  984. x->props.reqid, x->props.family);
  985. hlist_add_head_rcu(&x->bydst, net->xfrm.state_bydst + h);
  986. h = xfrm_src_hash(net, &x->id.daddr, &x->props.saddr, x->props.family);
  987. hlist_add_head_rcu(&x->bysrc, net->xfrm.state_bysrc + h);
  988. if (x->id.spi) {
  989. h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto,
  990. x->props.family);
  991. hlist_add_head_rcu(&x->byspi, net->xfrm.state_byspi + h);
  992. }
  993. tasklet_hrtimer_start(&x->mtimer, ktime_set(1, 0), HRTIMER_MODE_REL);
  994. if (x->replay_maxage)
  995. mod_timer(&x->rtimer, jiffies + x->replay_maxage);
  996. net->xfrm.state_num++;
  997. xfrm_hash_grow_check(net, x->bydst.next != NULL);
  998. }
  999. /* net->xfrm.xfrm_state_lock is held */
  1000. static void __xfrm_state_bump_genids(struct xfrm_state *xnew)
  1001. {
  1002. struct net *net = xs_net(xnew);
  1003. unsigned short family = xnew->props.family;
  1004. u32 reqid = xnew->props.reqid;
  1005. struct xfrm_state *x;
  1006. unsigned int h;
  1007. u32 mark = xnew->mark.v & xnew->mark.m;
  1008. u32 if_id = xnew->if_id;
  1009. h = xfrm_dst_hash(net, &xnew->id.daddr, &xnew->props.saddr, reqid, family);
  1010. hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
  1011. if (x->props.family == family &&
  1012. x->props.reqid == reqid &&
  1013. x->if_id == if_id &&
  1014. (mark & x->mark.m) == x->mark.v &&
  1015. xfrm_addr_equal(&x->id.daddr, &xnew->id.daddr, family) &&
  1016. xfrm_addr_equal(&x->props.saddr, &xnew->props.saddr, family))
  1017. x->genid++;
  1018. }
  1019. }
  1020. void xfrm_state_insert(struct xfrm_state *x)
  1021. {
  1022. struct net *net = xs_net(x);
  1023. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1024. __xfrm_state_bump_genids(x);
  1025. __xfrm_state_insert(x);
  1026. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1027. }
  1028. EXPORT_SYMBOL(xfrm_state_insert);
  1029. /* net->xfrm.xfrm_state_lock is held */
  1030. static struct xfrm_state *__find_acq_core(struct net *net,
  1031. const struct xfrm_mark *m,
  1032. unsigned short family, u8 mode,
  1033. u32 reqid, u32 if_id, u8 proto,
  1034. const xfrm_address_t *daddr,
  1035. const xfrm_address_t *saddr,
  1036. int create)
  1037. {
  1038. unsigned int h = xfrm_dst_hash(net, daddr, saddr, reqid, family);
  1039. struct xfrm_state *x;
  1040. u32 mark = m->v & m->m;
  1041. hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
  1042. if (x->props.reqid != reqid ||
  1043. x->props.mode != mode ||
  1044. x->props.family != family ||
  1045. x->km.state != XFRM_STATE_ACQ ||
  1046. x->id.spi != 0 ||
  1047. x->id.proto != proto ||
  1048. (mark & x->mark.m) != x->mark.v ||
  1049. !xfrm_addr_equal(&x->id.daddr, daddr, family) ||
  1050. !xfrm_addr_equal(&x->props.saddr, saddr, family))
  1051. continue;
  1052. xfrm_state_hold(x);
  1053. return x;
  1054. }
  1055. if (!create)
  1056. return NULL;
  1057. x = xfrm_state_alloc(net);
  1058. if (likely(x)) {
  1059. switch (family) {
  1060. case AF_INET:
  1061. x->sel.daddr.a4 = daddr->a4;
  1062. x->sel.saddr.a4 = saddr->a4;
  1063. x->sel.prefixlen_d = 32;
  1064. x->sel.prefixlen_s = 32;
  1065. x->props.saddr.a4 = saddr->a4;
  1066. x->id.daddr.a4 = daddr->a4;
  1067. break;
  1068. case AF_INET6:
  1069. x->sel.daddr.in6 = daddr->in6;
  1070. x->sel.saddr.in6 = saddr->in6;
  1071. x->sel.prefixlen_d = 128;
  1072. x->sel.prefixlen_s = 128;
  1073. x->props.saddr.in6 = saddr->in6;
  1074. x->id.daddr.in6 = daddr->in6;
  1075. break;
  1076. }
  1077. x->km.state = XFRM_STATE_ACQ;
  1078. x->id.proto = proto;
  1079. x->props.family = family;
  1080. x->props.mode = mode;
  1081. x->props.reqid = reqid;
  1082. x->if_id = if_id;
  1083. x->mark.v = m->v;
  1084. x->mark.m = m->m;
  1085. x->lft.hard_add_expires_seconds = net->xfrm.sysctl_acq_expires;
  1086. xfrm_state_hold(x);
  1087. tasklet_hrtimer_start(&x->mtimer, ktime_set(net->xfrm.sysctl_acq_expires, 0), HRTIMER_MODE_REL);
  1088. list_add(&x->km.all, &net->xfrm.state_all);
  1089. hlist_add_head_rcu(&x->bydst, net->xfrm.state_bydst + h);
  1090. h = xfrm_src_hash(net, daddr, saddr, family);
  1091. hlist_add_head_rcu(&x->bysrc, net->xfrm.state_bysrc + h);
  1092. net->xfrm.state_num++;
  1093. xfrm_hash_grow_check(net, x->bydst.next != NULL);
  1094. }
  1095. return x;
  1096. }
  1097. static struct xfrm_state *__xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq);
  1098. int xfrm_state_add(struct xfrm_state *x)
  1099. {
  1100. struct net *net = xs_net(x);
  1101. struct xfrm_state *x1, *to_put;
  1102. int family;
  1103. int err;
  1104. u32 mark = x->mark.v & x->mark.m;
  1105. int use_spi = xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY);
  1106. family = x->props.family;
  1107. to_put = NULL;
  1108. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1109. x1 = __xfrm_state_locate(x, use_spi, family);
  1110. if (x1) {
  1111. to_put = x1;
  1112. x1 = NULL;
  1113. err = -EEXIST;
  1114. goto out;
  1115. }
  1116. if (use_spi && x->km.seq) {
  1117. x1 = __xfrm_find_acq_byseq(net, mark, x->km.seq);
  1118. if (x1 && ((x1->id.proto != x->id.proto) ||
  1119. !xfrm_addr_equal(&x1->id.daddr, &x->id.daddr, family))) {
  1120. to_put = x1;
  1121. x1 = NULL;
  1122. }
  1123. }
  1124. if (use_spi && !x1)
  1125. x1 = __find_acq_core(net, &x->mark, family, x->props.mode,
  1126. x->props.reqid, x->if_id, x->id.proto,
  1127. &x->id.daddr, &x->props.saddr, 0);
  1128. __xfrm_state_bump_genids(x);
  1129. __xfrm_state_insert(x);
  1130. err = 0;
  1131. out:
  1132. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1133. if (x1) {
  1134. xfrm_state_delete(x1);
  1135. xfrm_state_put(x1);
  1136. }
  1137. if (to_put)
  1138. xfrm_state_put(to_put);
  1139. return err;
  1140. }
  1141. EXPORT_SYMBOL(xfrm_state_add);
  1142. #ifdef CONFIG_XFRM_MIGRATE
  1143. static inline int clone_security(struct xfrm_state *x, struct xfrm_sec_ctx *security)
  1144. {
  1145. struct xfrm_user_sec_ctx *uctx;
  1146. int size = sizeof(*uctx) + security->ctx_len;
  1147. int err;
  1148. uctx = kmalloc(size, GFP_KERNEL);
  1149. if (!uctx)
  1150. return -ENOMEM;
  1151. uctx->exttype = XFRMA_SEC_CTX;
  1152. uctx->len = size;
  1153. uctx->ctx_doi = security->ctx_doi;
  1154. uctx->ctx_alg = security->ctx_alg;
  1155. uctx->ctx_len = security->ctx_len;
  1156. memcpy(uctx + 1, security->ctx_str, security->ctx_len);
  1157. err = security_xfrm_state_alloc(x, uctx);
  1158. kfree(uctx);
  1159. if (err)
  1160. return err;
  1161. return 0;
  1162. }
  1163. static struct xfrm_state *xfrm_state_clone(struct xfrm_state *orig,
  1164. struct xfrm_encap_tmpl *encap)
  1165. {
  1166. struct net *net = xs_net(orig);
  1167. struct xfrm_state *x = xfrm_state_alloc(net);
  1168. if (!x)
  1169. goto out;
  1170. memcpy(&x->id, &orig->id, sizeof(x->id));
  1171. memcpy(&x->sel, &orig->sel, sizeof(x->sel));
  1172. memcpy(&x->lft, &orig->lft, sizeof(x->lft));
  1173. x->props.mode = orig->props.mode;
  1174. x->props.replay_window = orig->props.replay_window;
  1175. x->props.reqid = orig->props.reqid;
  1176. x->props.family = orig->props.family;
  1177. x->props.saddr = orig->props.saddr;
  1178. if (orig->aalg) {
  1179. x->aalg = xfrm_algo_auth_clone(orig->aalg);
  1180. if (!x->aalg)
  1181. goto error;
  1182. }
  1183. x->props.aalgo = orig->props.aalgo;
  1184. if (orig->aead) {
  1185. x->aead = xfrm_algo_aead_clone(orig->aead);
  1186. x->geniv = orig->geniv;
  1187. if (!x->aead)
  1188. goto error;
  1189. }
  1190. if (orig->ealg) {
  1191. x->ealg = xfrm_algo_clone(orig->ealg);
  1192. if (!x->ealg)
  1193. goto error;
  1194. }
  1195. x->props.ealgo = orig->props.ealgo;
  1196. if (orig->calg) {
  1197. x->calg = xfrm_algo_clone(orig->calg);
  1198. if (!x->calg)
  1199. goto error;
  1200. }
  1201. x->props.calgo = orig->props.calgo;
  1202. if (encap || orig->encap) {
  1203. if (encap)
  1204. x->encap = kmemdup(encap, sizeof(*x->encap),
  1205. GFP_KERNEL);
  1206. else
  1207. x->encap = kmemdup(orig->encap, sizeof(*x->encap),
  1208. GFP_KERNEL);
  1209. if (!x->encap)
  1210. goto error;
  1211. }
  1212. if (orig->security)
  1213. if (clone_security(x, orig->security))
  1214. goto error;
  1215. if (orig->coaddr) {
  1216. x->coaddr = kmemdup(orig->coaddr, sizeof(*x->coaddr),
  1217. GFP_KERNEL);
  1218. if (!x->coaddr)
  1219. goto error;
  1220. }
  1221. if (orig->replay_esn) {
  1222. if (xfrm_replay_clone(x, orig))
  1223. goto error;
  1224. }
  1225. memcpy(&x->mark, &orig->mark, sizeof(x->mark));
  1226. memcpy(&x->props.smark, &orig->props.smark, sizeof(x->props.smark));
  1227. if (xfrm_init_state(x) < 0)
  1228. goto error;
  1229. x->props.flags = orig->props.flags;
  1230. x->props.extra_flags = orig->props.extra_flags;
  1231. x->if_id = orig->if_id;
  1232. x->tfcpad = orig->tfcpad;
  1233. x->replay_maxdiff = orig->replay_maxdiff;
  1234. x->replay_maxage = orig->replay_maxage;
  1235. memcpy(&x->curlft, &orig->curlft, sizeof(x->curlft));
  1236. x->km.state = orig->km.state;
  1237. x->km.seq = orig->km.seq;
  1238. x->replay = orig->replay;
  1239. x->preplay = orig->preplay;
  1240. return x;
  1241. error:
  1242. xfrm_state_put(x);
  1243. out:
  1244. return NULL;
  1245. }
  1246. struct xfrm_state *xfrm_migrate_state_find(struct xfrm_migrate *m, struct net *net)
  1247. {
  1248. unsigned int h;
  1249. struct xfrm_state *x = NULL;
  1250. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1251. if (m->reqid) {
  1252. h = xfrm_dst_hash(net, &m->old_daddr, &m->old_saddr,
  1253. m->reqid, m->old_family);
  1254. hlist_for_each_entry(x, net->xfrm.state_bydst+h, bydst) {
  1255. if (x->props.mode != m->mode ||
  1256. x->id.proto != m->proto)
  1257. continue;
  1258. if (m->reqid && x->props.reqid != m->reqid)
  1259. continue;
  1260. if (!xfrm_addr_equal(&x->id.daddr, &m->old_daddr,
  1261. m->old_family) ||
  1262. !xfrm_addr_equal(&x->props.saddr, &m->old_saddr,
  1263. m->old_family))
  1264. continue;
  1265. xfrm_state_hold(x);
  1266. break;
  1267. }
  1268. } else {
  1269. h = xfrm_src_hash(net, &m->old_daddr, &m->old_saddr,
  1270. m->old_family);
  1271. hlist_for_each_entry(x, net->xfrm.state_bysrc+h, bysrc) {
  1272. if (x->props.mode != m->mode ||
  1273. x->id.proto != m->proto)
  1274. continue;
  1275. if (!xfrm_addr_equal(&x->id.daddr, &m->old_daddr,
  1276. m->old_family) ||
  1277. !xfrm_addr_equal(&x->props.saddr, &m->old_saddr,
  1278. m->old_family))
  1279. continue;
  1280. xfrm_state_hold(x);
  1281. break;
  1282. }
  1283. }
  1284. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1285. return x;
  1286. }
  1287. EXPORT_SYMBOL(xfrm_migrate_state_find);
  1288. struct xfrm_state *xfrm_state_migrate(struct xfrm_state *x,
  1289. struct xfrm_migrate *m,
  1290. struct xfrm_encap_tmpl *encap)
  1291. {
  1292. struct xfrm_state *xc;
  1293. xc = xfrm_state_clone(x, encap);
  1294. if (!xc)
  1295. return NULL;
  1296. memcpy(&xc->id.daddr, &m->new_daddr, sizeof(xc->id.daddr));
  1297. memcpy(&xc->props.saddr, &m->new_saddr, sizeof(xc->props.saddr));
  1298. /* add state */
  1299. if (xfrm_addr_equal(&x->id.daddr, &m->new_daddr, m->new_family)) {
  1300. /* a care is needed when the destination address of the
  1301. state is to be updated as it is a part of triplet */
  1302. xfrm_state_insert(xc);
  1303. } else {
  1304. if (xfrm_state_add(xc) < 0)
  1305. goto error;
  1306. }
  1307. return xc;
  1308. error:
  1309. xfrm_state_put(xc);
  1310. return NULL;
  1311. }
  1312. EXPORT_SYMBOL(xfrm_state_migrate);
  1313. #endif
  1314. int xfrm_state_update(struct xfrm_state *x)
  1315. {
  1316. struct xfrm_state *x1, *to_put;
  1317. int err;
  1318. int use_spi = xfrm_id_proto_match(x->id.proto, IPSEC_PROTO_ANY);
  1319. struct net *net = xs_net(x);
  1320. to_put = NULL;
  1321. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1322. x1 = __xfrm_state_locate(x, use_spi, x->props.family);
  1323. err = -ESRCH;
  1324. if (!x1)
  1325. goto out;
  1326. if (xfrm_state_kern(x1)) {
  1327. to_put = x1;
  1328. err = -EEXIST;
  1329. goto out;
  1330. }
  1331. if (x1->km.state == XFRM_STATE_ACQ) {
  1332. __xfrm_state_insert(x);
  1333. x = NULL;
  1334. }
  1335. err = 0;
  1336. out:
  1337. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1338. if (to_put)
  1339. xfrm_state_put(to_put);
  1340. if (err)
  1341. return err;
  1342. if (!x) {
  1343. xfrm_state_delete(x1);
  1344. xfrm_state_put(x1);
  1345. return 0;
  1346. }
  1347. err = -EINVAL;
  1348. spin_lock_bh(&x1->lock);
  1349. if (likely(x1->km.state == XFRM_STATE_VALID)) {
  1350. if (x->encap && x1->encap &&
  1351. x->encap->encap_type == x1->encap->encap_type)
  1352. memcpy(x1->encap, x->encap, sizeof(*x1->encap));
  1353. else if (x->encap || x1->encap)
  1354. goto fail;
  1355. if (x->coaddr && x1->coaddr) {
  1356. memcpy(x1->coaddr, x->coaddr, sizeof(*x1->coaddr));
  1357. }
  1358. if (!use_spi && memcmp(&x1->sel, &x->sel, sizeof(x1->sel)))
  1359. memcpy(&x1->sel, &x->sel, sizeof(x1->sel));
  1360. memcpy(&x1->lft, &x->lft, sizeof(x1->lft));
  1361. x1->km.dying = 0;
  1362. tasklet_hrtimer_start(&x1->mtimer, ktime_set(1, 0), HRTIMER_MODE_REL);
  1363. if (x1->curlft.use_time)
  1364. xfrm_state_check_expire(x1);
  1365. if (x->props.smark.m || x->props.smark.v || x->if_id) {
  1366. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1367. if (x->props.smark.m || x->props.smark.v)
  1368. x1->props.smark = x->props.smark;
  1369. if (x->if_id)
  1370. x1->if_id = x->if_id;
  1371. __xfrm_state_bump_genids(x1);
  1372. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1373. }
  1374. err = 0;
  1375. x->km.state = XFRM_STATE_DEAD;
  1376. __xfrm_state_put(x);
  1377. }
  1378. fail:
  1379. spin_unlock_bh(&x1->lock);
  1380. xfrm_state_put(x1);
  1381. return err;
  1382. }
  1383. EXPORT_SYMBOL(xfrm_state_update);
  1384. int xfrm_state_check_expire(struct xfrm_state *x)
  1385. {
  1386. if (!x->curlft.use_time)
  1387. x->curlft.use_time = ktime_get_real_seconds();
  1388. if (x->curlft.bytes >= x->lft.hard_byte_limit ||
  1389. x->curlft.packets >= x->lft.hard_packet_limit) {
  1390. x->km.state = XFRM_STATE_EXPIRED;
  1391. tasklet_hrtimer_start(&x->mtimer, 0, HRTIMER_MODE_REL);
  1392. return -EINVAL;
  1393. }
  1394. if (!x->km.dying &&
  1395. (x->curlft.bytes >= x->lft.soft_byte_limit ||
  1396. x->curlft.packets >= x->lft.soft_packet_limit)) {
  1397. x->km.dying = 1;
  1398. km_state_expired(x, 0, 0);
  1399. }
  1400. return 0;
  1401. }
  1402. EXPORT_SYMBOL(xfrm_state_check_expire);
  1403. struct xfrm_state *
  1404. xfrm_state_lookup(struct net *net, u32 mark, const xfrm_address_t *daddr, __be32 spi,
  1405. u8 proto, unsigned short family)
  1406. {
  1407. struct xfrm_state *x;
  1408. rcu_read_lock();
  1409. x = __xfrm_state_lookup(net, mark, daddr, spi, proto, family);
  1410. rcu_read_unlock();
  1411. return x;
  1412. }
  1413. EXPORT_SYMBOL(xfrm_state_lookup);
  1414. struct xfrm_state *
  1415. xfrm_state_lookup_byaddr(struct net *net, u32 mark,
  1416. const xfrm_address_t *daddr, const xfrm_address_t *saddr,
  1417. u8 proto, unsigned short family)
  1418. {
  1419. struct xfrm_state *x;
  1420. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1421. x = __xfrm_state_lookup_byaddr(net, mark, daddr, saddr, proto, family);
  1422. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1423. return x;
  1424. }
  1425. EXPORT_SYMBOL(xfrm_state_lookup_byaddr);
  1426. struct xfrm_state *
  1427. xfrm_find_acq(struct net *net, const struct xfrm_mark *mark, u8 mode, u32 reqid,
  1428. u32 if_id, u8 proto, const xfrm_address_t *daddr,
  1429. const xfrm_address_t *saddr, int create, unsigned short family)
  1430. {
  1431. struct xfrm_state *x;
  1432. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1433. x = __find_acq_core(net, mark, family, mode, reqid, if_id, proto, daddr, saddr, create);
  1434. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1435. return x;
  1436. }
  1437. EXPORT_SYMBOL(xfrm_find_acq);
  1438. #ifdef CONFIG_XFRM_SUB_POLICY
  1439. int
  1440. xfrm_tmpl_sort(struct xfrm_tmpl **dst, struct xfrm_tmpl **src, int n,
  1441. unsigned short family, struct net *net)
  1442. {
  1443. int i;
  1444. int err = 0;
  1445. struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
  1446. if (!afinfo)
  1447. return -EAFNOSUPPORT;
  1448. spin_lock_bh(&net->xfrm.xfrm_state_lock); /*FIXME*/
  1449. if (afinfo->tmpl_sort)
  1450. err = afinfo->tmpl_sort(dst, src, n);
  1451. else
  1452. for (i = 0; i < n; i++)
  1453. dst[i] = src[i];
  1454. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1455. rcu_read_unlock();
  1456. return err;
  1457. }
  1458. EXPORT_SYMBOL(xfrm_tmpl_sort);
  1459. int
  1460. xfrm_state_sort(struct xfrm_state **dst, struct xfrm_state **src, int n,
  1461. unsigned short family)
  1462. {
  1463. int i;
  1464. int err = 0;
  1465. struct xfrm_state_afinfo *afinfo = xfrm_state_get_afinfo(family);
  1466. struct net *net = xs_net(*src);
  1467. if (!afinfo)
  1468. return -EAFNOSUPPORT;
  1469. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1470. if (afinfo->state_sort)
  1471. err = afinfo->state_sort(dst, src, n);
  1472. else
  1473. for (i = 0; i < n; i++)
  1474. dst[i] = src[i];
  1475. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1476. rcu_read_unlock();
  1477. return err;
  1478. }
  1479. EXPORT_SYMBOL(xfrm_state_sort);
  1480. #endif
  1481. /* Silly enough, but I'm lazy to build resolution list */
  1482. static struct xfrm_state *__xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq)
  1483. {
  1484. int i;
  1485. for (i = 0; i <= net->xfrm.state_hmask; i++) {
  1486. struct xfrm_state *x;
  1487. hlist_for_each_entry(x, net->xfrm.state_bydst+i, bydst) {
  1488. if (x->km.seq == seq &&
  1489. (mark & x->mark.m) == x->mark.v &&
  1490. x->km.state == XFRM_STATE_ACQ) {
  1491. xfrm_state_hold(x);
  1492. return x;
  1493. }
  1494. }
  1495. }
  1496. return NULL;
  1497. }
  1498. struct xfrm_state *xfrm_find_acq_byseq(struct net *net, u32 mark, u32 seq)
  1499. {
  1500. struct xfrm_state *x;
  1501. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1502. x = __xfrm_find_acq_byseq(net, mark, seq);
  1503. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1504. return x;
  1505. }
  1506. EXPORT_SYMBOL(xfrm_find_acq_byseq);
  1507. u32 xfrm_get_acqseq(void)
  1508. {
  1509. u32 res;
  1510. static atomic_t acqseq;
  1511. do {
  1512. res = atomic_inc_return(&acqseq);
  1513. } while (!res);
  1514. return res;
  1515. }
  1516. EXPORT_SYMBOL(xfrm_get_acqseq);
  1517. int verify_spi_info(u8 proto, u32 min, u32 max)
  1518. {
  1519. switch (proto) {
  1520. case IPPROTO_AH:
  1521. case IPPROTO_ESP:
  1522. break;
  1523. case IPPROTO_COMP:
  1524. /* IPCOMP spi is 16-bits. */
  1525. if (max >= 0x10000)
  1526. return -EINVAL;
  1527. break;
  1528. default:
  1529. return -EINVAL;
  1530. }
  1531. if (min > max)
  1532. return -EINVAL;
  1533. return 0;
  1534. }
  1535. EXPORT_SYMBOL(verify_spi_info);
  1536. int xfrm_alloc_spi(struct xfrm_state *x, u32 low, u32 high)
  1537. {
  1538. struct net *net = xs_net(x);
  1539. unsigned int h;
  1540. struct xfrm_state *x0;
  1541. int err = -ENOENT;
  1542. __be32 minspi = htonl(low);
  1543. __be32 maxspi = htonl(high);
  1544. __be32 newspi = 0;
  1545. u32 mark = x->mark.v & x->mark.m;
  1546. spin_lock_bh(&x->lock);
  1547. if (x->km.state == XFRM_STATE_DEAD)
  1548. goto unlock;
  1549. err = 0;
  1550. if (x->id.spi)
  1551. goto unlock;
  1552. err = -ENOENT;
  1553. if (minspi == maxspi) {
  1554. x0 = xfrm_state_lookup(net, mark, &x->id.daddr, minspi, x->id.proto, x->props.family);
  1555. if (x0) {
  1556. xfrm_state_put(x0);
  1557. goto unlock;
  1558. }
  1559. newspi = minspi;
  1560. } else {
  1561. u32 spi = 0;
  1562. for (h = 0; h < high-low+1; h++) {
  1563. spi = low + prandom_u32()%(high-low+1);
  1564. x0 = xfrm_state_lookup(net, mark, &x->id.daddr, htonl(spi), x->id.proto, x->props.family);
  1565. if (x0 == NULL) {
  1566. newspi = htonl(spi);
  1567. break;
  1568. }
  1569. xfrm_state_put(x0);
  1570. }
  1571. }
  1572. if (newspi) {
  1573. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1574. x->id.spi = newspi;
  1575. h = xfrm_spi_hash(net, &x->id.daddr, x->id.spi, x->id.proto, x->props.family);
  1576. hlist_add_head_rcu(&x->byspi, net->xfrm.state_byspi + h);
  1577. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1578. err = 0;
  1579. }
  1580. unlock:
  1581. spin_unlock_bh(&x->lock);
  1582. return err;
  1583. }
  1584. EXPORT_SYMBOL(xfrm_alloc_spi);
  1585. static bool __xfrm_state_filter_match(struct xfrm_state *x,
  1586. struct xfrm_address_filter *filter)
  1587. {
  1588. if (filter) {
  1589. if ((filter->family == AF_INET ||
  1590. filter->family == AF_INET6) &&
  1591. x->props.family != filter->family)
  1592. return false;
  1593. return addr_match(&x->props.saddr, &filter->saddr,
  1594. filter->splen) &&
  1595. addr_match(&x->id.daddr, &filter->daddr,
  1596. filter->dplen);
  1597. }
  1598. return true;
  1599. }
  1600. int xfrm_state_walk(struct net *net, struct xfrm_state_walk *walk,
  1601. int (*func)(struct xfrm_state *, int, void*),
  1602. void *data)
  1603. {
  1604. struct xfrm_state *state;
  1605. struct xfrm_state_walk *x;
  1606. int err = 0;
  1607. if (walk->seq != 0 && list_empty(&walk->all))
  1608. return 0;
  1609. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1610. if (list_empty(&walk->all))
  1611. x = list_first_entry(&net->xfrm.state_all, struct xfrm_state_walk, all);
  1612. else
  1613. x = list_first_entry(&walk->all, struct xfrm_state_walk, all);
  1614. list_for_each_entry_from(x, &net->xfrm.state_all, all) {
  1615. if (x->state == XFRM_STATE_DEAD)
  1616. continue;
  1617. state = container_of(x, struct xfrm_state, km);
  1618. if (!xfrm_id_proto_match(state->id.proto, walk->proto))
  1619. continue;
  1620. if (!__xfrm_state_filter_match(state, walk->filter))
  1621. continue;
  1622. err = func(state, walk->seq, data);
  1623. if (err) {
  1624. list_move_tail(&walk->all, &x->all);
  1625. goto out;
  1626. }
  1627. walk->seq++;
  1628. }
  1629. if (walk->seq == 0) {
  1630. err = -ENOENT;
  1631. goto out;
  1632. }
  1633. list_del_init(&walk->all);
  1634. out:
  1635. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1636. return err;
  1637. }
  1638. EXPORT_SYMBOL(xfrm_state_walk);
  1639. void xfrm_state_walk_init(struct xfrm_state_walk *walk, u8 proto,
  1640. struct xfrm_address_filter *filter)
  1641. {
  1642. INIT_LIST_HEAD(&walk->all);
  1643. walk->proto = proto;
  1644. walk->state = XFRM_STATE_DEAD;
  1645. walk->seq = 0;
  1646. walk->filter = filter;
  1647. }
  1648. EXPORT_SYMBOL(xfrm_state_walk_init);
  1649. void xfrm_state_walk_done(struct xfrm_state_walk *walk, struct net *net)
  1650. {
  1651. kfree(walk->filter);
  1652. if (list_empty(&walk->all))
  1653. return;
  1654. spin_lock_bh(&net->xfrm.xfrm_state_lock);
  1655. list_del(&walk->all);
  1656. spin_unlock_bh(&net->xfrm.xfrm_state_lock);
  1657. }
  1658. EXPORT_SYMBOL(xfrm_state_walk_done);
  1659. static void xfrm_replay_timer_handler(struct timer_list *t)
  1660. {
  1661. struct xfrm_state *x = from_timer(x, t, rtimer);
  1662. spin_lock(&x->lock);
  1663. if (x->km.state == XFRM_STATE_VALID) {
  1664. if (xfrm_aevent_is_on(xs_net(x)))
  1665. x->repl->notify(x, XFRM_REPLAY_TIMEOUT);
  1666. else
  1667. x->xflags |= XFRM_TIME_DEFER;
  1668. }
  1669. spin_unlock(&x->lock);
  1670. }
  1671. static LIST_HEAD(xfrm_km_list);
  1672. void km_policy_notify(struct xfrm_policy *xp, int dir, const struct km_event *c)
  1673. {
  1674. struct xfrm_mgr *km;
  1675. rcu_read_lock();
  1676. list_for_each_entry_rcu(km, &xfrm_km_list, list)
  1677. if (km->notify_policy)
  1678. km->notify_policy(xp, dir, c);
  1679. rcu_read_unlock();
  1680. }
  1681. void km_state_notify(struct xfrm_state *x, const struct km_event *c)
  1682. {
  1683. struct xfrm_mgr *km;
  1684. rcu_read_lock();
  1685. list_for_each_entry_rcu(km, &xfrm_km_list, list)
  1686. if (km->notify)
  1687. km->notify(x, c);
  1688. rcu_read_unlock();
  1689. }
  1690. EXPORT_SYMBOL(km_policy_notify);
  1691. EXPORT_SYMBOL(km_state_notify);
  1692. void km_state_expired(struct xfrm_state *x, int hard, u32 portid)
  1693. {
  1694. struct km_event c;
  1695. c.data.hard = hard;
  1696. c.portid = portid;
  1697. c.event = XFRM_MSG_EXPIRE;
  1698. km_state_notify(x, &c);
  1699. }
  1700. EXPORT_SYMBOL(km_state_expired);
  1701. /*
  1702. * We send to all registered managers regardless of failure
  1703. * We are happy with one success
  1704. */
  1705. int km_query(struct xfrm_state *x, struct xfrm_tmpl *t, struct xfrm_policy *pol)
  1706. {
  1707. int err = -EINVAL, acqret;
  1708. struct xfrm_mgr *km;
  1709. rcu_read_lock();
  1710. list_for_each_entry_rcu(km, &xfrm_km_list, list) {
  1711. acqret = km->acquire(x, t, pol);
  1712. if (!acqret)
  1713. err = acqret;
  1714. }
  1715. rcu_read_unlock();
  1716. return err;
  1717. }
  1718. EXPORT_SYMBOL(km_query);
  1719. int km_new_mapping(struct xfrm_state *x, xfrm_address_t *ipaddr, __be16 sport)
  1720. {
  1721. int err = -EINVAL;
  1722. struct xfrm_mgr *km;
  1723. rcu_read_lock();
  1724. list_for_each_entry_rcu(km, &xfrm_km_list, list) {
  1725. if (km->new_mapping)
  1726. err = km->new_mapping(x, ipaddr, sport);
  1727. if (!err)
  1728. break;
  1729. }
  1730. rcu_read_unlock();
  1731. return err;
  1732. }
  1733. EXPORT_SYMBOL(km_new_mapping);
  1734. void km_policy_expired(struct xfrm_policy *pol, int dir, int hard, u32 portid)
  1735. {
  1736. struct km_event c;
  1737. c.data.hard = hard;
  1738. c.portid = portid;
  1739. c.event = XFRM_MSG_POLEXPIRE;
  1740. km_policy_notify(pol, dir, &c);
  1741. }
  1742. EXPORT_SYMBOL(km_policy_expired);
  1743. #ifdef CONFIG_XFRM_MIGRATE
  1744. int km_migrate(const struct xfrm_selector *sel, u8 dir, u8 type,
  1745. const struct xfrm_migrate *m, int num_migrate,
  1746. const struct xfrm_kmaddress *k,
  1747. const struct xfrm_encap_tmpl *encap)
  1748. {
  1749. int err = -EINVAL;
  1750. int ret;
  1751. struct xfrm_mgr *km;
  1752. rcu_read_lock();
  1753. list_for_each_entry_rcu(km, &xfrm_km_list, list) {
  1754. if (km->migrate) {
  1755. ret = km->migrate(sel, dir, type, m, num_migrate, k,
  1756. encap);
  1757. if (!ret)
  1758. err = ret;
  1759. }
  1760. }
  1761. rcu_read_unlock();
  1762. return err;
  1763. }
  1764. EXPORT_SYMBOL(km_migrate);
  1765. #endif
  1766. int km_report(struct net *net, u8 proto, struct xfrm_selector *sel, xfrm_address_t *addr)
  1767. {
  1768. int err = -EINVAL;
  1769. int ret;
  1770. struct xfrm_mgr *km;
  1771. rcu_read_lock();
  1772. list_for_each_entry_rcu(km, &xfrm_km_list, list) {
  1773. if (km->report) {
  1774. ret = km->report(net, proto, sel, addr);
  1775. if (!ret)
  1776. err = ret;
  1777. }
  1778. }
  1779. rcu_read_unlock();
  1780. return err;
  1781. }
  1782. EXPORT_SYMBOL(km_report);
  1783. bool km_is_alive(const struct km_event *c)
  1784. {
  1785. struct xfrm_mgr *km;
  1786. bool is_alive = false;
  1787. rcu_read_lock();
  1788. list_for_each_entry_rcu(km, &xfrm_km_list, list) {
  1789. if (km->is_alive && km->is_alive(c)) {
  1790. is_alive = true;
  1791. break;
  1792. }
  1793. }
  1794. rcu_read_unlock();
  1795. return is_alive;
  1796. }
  1797. EXPORT_SYMBOL(km_is_alive);
  1798. int xfrm_user_policy(struct sock *sk, int optname, u8 __user *optval, int optlen)
  1799. {
  1800. int err;
  1801. u8 *data;
  1802. struct xfrm_mgr *km;
  1803. struct xfrm_policy *pol = NULL;
  1804. #ifdef CONFIG_COMPAT
  1805. if (in_compat_syscall())
  1806. return -EOPNOTSUPP;
  1807. #endif
  1808. if (!optval && !optlen) {
  1809. xfrm_sk_policy_insert(sk, XFRM_POLICY_IN, NULL);
  1810. xfrm_sk_policy_insert(sk, XFRM_POLICY_OUT, NULL);
  1811. __sk_dst_reset(sk);
  1812. return 0;
  1813. }
  1814. if (optlen <= 0 || optlen > PAGE_SIZE)
  1815. return -EMSGSIZE;
  1816. data = memdup_user(optval, optlen);
  1817. if (IS_ERR(data))
  1818. return PTR_ERR(data);
  1819. err = -EINVAL;
  1820. rcu_read_lock();
  1821. list_for_each_entry_rcu(km, &xfrm_km_list, list) {
  1822. pol = km->compile_policy(sk, optname, data,
  1823. optlen, &err);
  1824. if (err >= 0)
  1825. break;
  1826. }
  1827. rcu_read_unlock();
  1828. if (err >= 0) {
  1829. xfrm_sk_policy_insert(sk, err, pol);
  1830. xfrm_pol_put(pol);
  1831. __sk_dst_reset(sk);
  1832. err = 0;
  1833. }
  1834. kfree(data);
  1835. return err;
  1836. }
  1837. EXPORT_SYMBOL(xfrm_user_policy);
  1838. static DEFINE_SPINLOCK(xfrm_km_lock);
  1839. int xfrm_register_km(struct xfrm_mgr *km)
  1840. {
  1841. spin_lock_bh(&xfrm_km_lock);
  1842. list_add_tail_rcu(&km->list, &xfrm_km_list);
  1843. spin_unlock_bh(&xfrm_km_lock);
  1844. return 0;
  1845. }
  1846. EXPORT_SYMBOL(xfrm_register_km);
  1847. int xfrm_unregister_km(struct xfrm_mgr *km)
  1848. {
  1849. spin_lock_bh(&xfrm_km_lock);
  1850. list_del_rcu(&km->list);
  1851. spin_unlock_bh(&xfrm_km_lock);
  1852. synchronize_rcu();
  1853. return 0;
  1854. }
  1855. EXPORT_SYMBOL(xfrm_unregister_km);
  1856. int xfrm_state_register_afinfo(struct xfrm_state_afinfo *afinfo)
  1857. {
  1858. int err = 0;
  1859. if (WARN_ON(afinfo->family >= NPROTO))
  1860. return -EAFNOSUPPORT;
  1861. spin_lock_bh(&xfrm_state_afinfo_lock);
  1862. if (unlikely(xfrm_state_afinfo[afinfo->family] != NULL))
  1863. err = -EEXIST;
  1864. else
  1865. rcu_assign_pointer(xfrm_state_afinfo[afinfo->family], afinfo);
  1866. spin_unlock_bh(&xfrm_state_afinfo_lock);
  1867. return err;
  1868. }
  1869. EXPORT_SYMBOL(xfrm_state_register_afinfo);
  1870. int xfrm_state_unregister_afinfo(struct xfrm_state_afinfo *afinfo)
  1871. {
  1872. int err = 0, family = afinfo->family;
  1873. if (WARN_ON(family >= NPROTO))
  1874. return -EAFNOSUPPORT;
  1875. spin_lock_bh(&xfrm_state_afinfo_lock);
  1876. if (likely(xfrm_state_afinfo[afinfo->family] != NULL)) {
  1877. if (rcu_access_pointer(xfrm_state_afinfo[family]) != afinfo)
  1878. err = -EINVAL;
  1879. else
  1880. RCU_INIT_POINTER(xfrm_state_afinfo[afinfo->family], NULL);
  1881. }
  1882. spin_unlock_bh(&xfrm_state_afinfo_lock);
  1883. synchronize_rcu();
  1884. return err;
  1885. }
  1886. EXPORT_SYMBOL(xfrm_state_unregister_afinfo);
  1887. struct xfrm_state_afinfo *xfrm_state_afinfo_get_rcu(unsigned int family)
  1888. {
  1889. if (unlikely(family >= NPROTO))
  1890. return NULL;
  1891. return rcu_dereference(xfrm_state_afinfo[family]);
  1892. }
  1893. struct xfrm_state_afinfo *xfrm_state_get_afinfo(unsigned int family)
  1894. {
  1895. struct xfrm_state_afinfo *afinfo;
  1896. if (unlikely(family >= NPROTO))
  1897. return NULL;
  1898. rcu_read_lock();
  1899. afinfo = rcu_dereference(xfrm_state_afinfo[family]);
  1900. if (unlikely(!afinfo))
  1901. rcu_read_unlock();
  1902. return afinfo;
  1903. }
  1904. void xfrm_flush_gc(void)
  1905. {
  1906. flush_work(&xfrm_state_gc_work);
  1907. }
  1908. EXPORT_SYMBOL(xfrm_flush_gc);
  1909. /* Temporarily located here until net/xfrm/xfrm_tunnel.c is created */
  1910. void xfrm_state_delete_tunnel(struct xfrm_state *x)
  1911. {
  1912. if (x->tunnel) {
  1913. struct xfrm_state *t = x->tunnel;
  1914. if (atomic_read(&t->tunnel_users) == 2)
  1915. xfrm_state_delete(t);
  1916. atomic_dec(&t->tunnel_users);
  1917. xfrm_state_put_sync(t);
  1918. x->tunnel = NULL;
  1919. }
  1920. }
  1921. EXPORT_SYMBOL(xfrm_state_delete_tunnel);
  1922. int xfrm_state_mtu(struct xfrm_state *x, int mtu)
  1923. {
  1924. const struct xfrm_type *type = READ_ONCE(x->type);
  1925. if (x->km.state == XFRM_STATE_VALID &&
  1926. type && type->get_mtu)
  1927. return type->get_mtu(x, mtu);
  1928. return mtu - x->props.header_len;
  1929. }
  1930. int __xfrm_init_state(struct xfrm_state *x, bool init_replay, bool offload)
  1931. {
  1932. struct xfrm_state_afinfo *afinfo;
  1933. struct xfrm_mode *inner_mode;
  1934. int family = x->props.family;
  1935. int err;
  1936. err = -EAFNOSUPPORT;
  1937. afinfo = xfrm_state_get_afinfo(family);
  1938. if (!afinfo)
  1939. goto error;
  1940. err = 0;
  1941. if (afinfo->init_flags)
  1942. err = afinfo->init_flags(x);
  1943. rcu_read_unlock();
  1944. if (err)
  1945. goto error;
  1946. err = -EPROTONOSUPPORT;
  1947. if (x->sel.family != AF_UNSPEC) {
  1948. inner_mode = xfrm_get_mode(x->props.mode, x->sel.family);
  1949. if (inner_mode == NULL)
  1950. goto error;
  1951. if (!(inner_mode->flags & XFRM_MODE_FLAG_TUNNEL) &&
  1952. family != x->sel.family) {
  1953. xfrm_put_mode(inner_mode);
  1954. goto error;
  1955. }
  1956. x->inner_mode = inner_mode;
  1957. } else {
  1958. struct xfrm_mode *inner_mode_iaf;
  1959. int iafamily = AF_INET;
  1960. inner_mode = xfrm_get_mode(x->props.mode, x->props.family);
  1961. if (inner_mode == NULL)
  1962. goto error;
  1963. if (!(inner_mode->flags & XFRM_MODE_FLAG_TUNNEL)) {
  1964. xfrm_put_mode(inner_mode);
  1965. goto error;
  1966. }
  1967. x->inner_mode = inner_mode;
  1968. if (x->props.family == AF_INET)
  1969. iafamily = AF_INET6;
  1970. inner_mode_iaf = xfrm_get_mode(x->props.mode, iafamily);
  1971. if (inner_mode_iaf) {
  1972. if (inner_mode_iaf->flags & XFRM_MODE_FLAG_TUNNEL)
  1973. x->inner_mode_iaf = inner_mode_iaf;
  1974. else
  1975. xfrm_put_mode(inner_mode_iaf);
  1976. }
  1977. }
  1978. x->type = xfrm_get_type(x->id.proto, family);
  1979. if (x->type == NULL)
  1980. goto error;
  1981. x->type_offload = xfrm_get_type_offload(x->id.proto, family, offload);
  1982. err = x->type->init_state(x);
  1983. if (err)
  1984. goto error;
  1985. x->outer_mode = xfrm_get_mode(x->props.mode, family);
  1986. if (x->outer_mode == NULL) {
  1987. err = -EPROTONOSUPPORT;
  1988. goto error;
  1989. }
  1990. if (init_replay) {
  1991. err = xfrm_init_replay(x);
  1992. if (err)
  1993. goto error;
  1994. }
  1995. error:
  1996. return err;
  1997. }
  1998. EXPORT_SYMBOL(__xfrm_init_state);
  1999. int xfrm_init_state(struct xfrm_state *x)
  2000. {
  2001. int err;
  2002. err = __xfrm_init_state(x, true, false);
  2003. if (!err)
  2004. x->km.state = XFRM_STATE_VALID;
  2005. return err;
  2006. }
  2007. EXPORT_SYMBOL(xfrm_init_state);
  2008. int __net_init xfrm_state_init(struct net *net)
  2009. {
  2010. unsigned int sz;
  2011. if (net_eq(net, &init_net))
  2012. xfrm_state_cache = KMEM_CACHE(xfrm_state,
  2013. SLAB_HWCACHE_ALIGN | SLAB_PANIC);
  2014. INIT_LIST_HEAD(&net->xfrm.state_all);
  2015. sz = sizeof(struct hlist_head) * 8;
  2016. net->xfrm.state_bydst = xfrm_hash_alloc(sz);
  2017. if (!net->xfrm.state_bydst)
  2018. goto out_bydst;
  2019. net->xfrm.state_bysrc = xfrm_hash_alloc(sz);
  2020. if (!net->xfrm.state_bysrc)
  2021. goto out_bysrc;
  2022. net->xfrm.state_byspi = xfrm_hash_alloc(sz);
  2023. if (!net->xfrm.state_byspi)
  2024. goto out_byspi;
  2025. net->xfrm.state_hmask = ((sz / sizeof(struct hlist_head)) - 1);
  2026. net->xfrm.state_num = 0;
  2027. INIT_WORK(&net->xfrm.state_hash_work, xfrm_hash_resize);
  2028. spin_lock_init(&net->xfrm.xfrm_state_lock);
  2029. seqcount_init(&net->xfrm.xfrm_state_hash_generation);
  2030. return 0;
  2031. out_byspi:
  2032. xfrm_hash_free(net->xfrm.state_bysrc, sz);
  2033. out_bysrc:
  2034. xfrm_hash_free(net->xfrm.state_bydst, sz);
  2035. out_bydst:
  2036. return -ENOMEM;
  2037. }
  2038. void xfrm_state_fini(struct net *net)
  2039. {
  2040. unsigned int sz;
  2041. flush_work(&net->xfrm.state_hash_work);
  2042. flush_work(&xfrm_state_gc_work);
  2043. xfrm_state_flush(net, 0, false, true);
  2044. WARN_ON(!list_empty(&net->xfrm.state_all));
  2045. sz = (net->xfrm.state_hmask + 1) * sizeof(struct hlist_head);
  2046. WARN_ON(!hlist_empty(net->xfrm.state_byspi));
  2047. xfrm_hash_free(net->xfrm.state_byspi, sz);
  2048. WARN_ON(!hlist_empty(net->xfrm.state_bysrc));
  2049. xfrm_hash_free(net->xfrm.state_bysrc, sz);
  2050. WARN_ON(!hlist_empty(net->xfrm.state_bydst));
  2051. xfrm_hash_free(net->xfrm.state_bydst, sz);
  2052. }
  2053. #ifdef CONFIG_AUDITSYSCALL
  2054. static void xfrm_audit_helper_sainfo(struct xfrm_state *x,
  2055. struct audit_buffer *audit_buf)
  2056. {
  2057. struct xfrm_sec_ctx *ctx = x->security;
  2058. u32 spi = ntohl(x->id.spi);
  2059. if (ctx)
  2060. audit_log_format(audit_buf, " sec_alg=%u sec_doi=%u sec_obj=%s",
  2061. ctx->ctx_alg, ctx->ctx_doi, ctx->ctx_str);
  2062. switch (x->props.family) {
  2063. case AF_INET:
  2064. audit_log_format(audit_buf, " src=%pI4 dst=%pI4",
  2065. &x->props.saddr.a4, &x->id.daddr.a4);
  2066. break;
  2067. case AF_INET6:
  2068. audit_log_format(audit_buf, " src=%pI6 dst=%pI6",
  2069. x->props.saddr.a6, x->id.daddr.a6);
  2070. break;
  2071. }
  2072. audit_log_format(audit_buf, " spi=%u(0x%x)", spi, spi);
  2073. }
  2074. static void xfrm_audit_helper_pktinfo(struct sk_buff *skb, u16 family,
  2075. struct audit_buffer *audit_buf)
  2076. {
  2077. const struct iphdr *iph4;
  2078. const struct ipv6hdr *iph6;
  2079. switch (family) {
  2080. case AF_INET:
  2081. iph4 = ip_hdr(skb);
  2082. audit_log_format(audit_buf, " src=%pI4 dst=%pI4",
  2083. &iph4->saddr, &iph4->daddr);
  2084. break;
  2085. case AF_INET6:
  2086. iph6 = ipv6_hdr(skb);
  2087. audit_log_format(audit_buf,
  2088. " src=%pI6 dst=%pI6 flowlbl=0x%x%02x%02x",
  2089. &iph6->saddr, &iph6->daddr,
  2090. iph6->flow_lbl[0] & 0x0f,
  2091. iph6->flow_lbl[1],
  2092. iph6->flow_lbl[2]);
  2093. break;
  2094. }
  2095. }
  2096. void xfrm_audit_state_add(struct xfrm_state *x, int result, bool task_valid)
  2097. {
  2098. struct audit_buffer *audit_buf;
  2099. audit_buf = xfrm_audit_start("SAD-add");
  2100. if (audit_buf == NULL)
  2101. return;
  2102. xfrm_audit_helper_usrinfo(task_valid, audit_buf);
  2103. xfrm_audit_helper_sainfo(x, audit_buf);
  2104. audit_log_format(audit_buf, " res=%u", result);
  2105. audit_log_end(audit_buf);
  2106. }
  2107. EXPORT_SYMBOL_GPL(xfrm_audit_state_add);
  2108. void xfrm_audit_state_delete(struct xfrm_state *x, int result, bool task_valid)
  2109. {
  2110. struct audit_buffer *audit_buf;
  2111. audit_buf = xfrm_audit_start("SAD-delete");
  2112. if (audit_buf == NULL)
  2113. return;
  2114. xfrm_audit_helper_usrinfo(task_valid, audit_buf);
  2115. xfrm_audit_helper_sainfo(x, audit_buf);
  2116. audit_log_format(audit_buf, " res=%u", result);
  2117. audit_log_end(audit_buf);
  2118. }
  2119. EXPORT_SYMBOL_GPL(xfrm_audit_state_delete);
  2120. void xfrm_audit_state_replay_overflow(struct xfrm_state *x,
  2121. struct sk_buff *skb)
  2122. {
  2123. struct audit_buffer *audit_buf;
  2124. u32 spi;
  2125. audit_buf = xfrm_audit_start("SA-replay-overflow");
  2126. if (audit_buf == NULL)
  2127. return;
  2128. xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
  2129. /* don't record the sequence number because it's inherent in this kind
  2130. * of audit message */
  2131. spi = ntohl(x->id.spi);
  2132. audit_log_format(audit_buf, " spi=%u(0x%x)", spi, spi);
  2133. audit_log_end(audit_buf);
  2134. }
  2135. EXPORT_SYMBOL_GPL(xfrm_audit_state_replay_overflow);
  2136. void xfrm_audit_state_replay(struct xfrm_state *x,
  2137. struct sk_buff *skb, __be32 net_seq)
  2138. {
  2139. struct audit_buffer *audit_buf;
  2140. u32 spi;
  2141. audit_buf = xfrm_audit_start("SA-replayed-pkt");
  2142. if (audit_buf == NULL)
  2143. return;
  2144. xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
  2145. spi = ntohl(x->id.spi);
  2146. audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
  2147. spi, spi, ntohl(net_seq));
  2148. audit_log_end(audit_buf);
  2149. }
  2150. EXPORT_SYMBOL_GPL(xfrm_audit_state_replay);
  2151. void xfrm_audit_state_notfound_simple(struct sk_buff *skb, u16 family)
  2152. {
  2153. struct audit_buffer *audit_buf;
  2154. audit_buf = xfrm_audit_start("SA-notfound");
  2155. if (audit_buf == NULL)
  2156. return;
  2157. xfrm_audit_helper_pktinfo(skb, family, audit_buf);
  2158. audit_log_end(audit_buf);
  2159. }
  2160. EXPORT_SYMBOL_GPL(xfrm_audit_state_notfound_simple);
  2161. void xfrm_audit_state_notfound(struct sk_buff *skb, u16 family,
  2162. __be32 net_spi, __be32 net_seq)
  2163. {
  2164. struct audit_buffer *audit_buf;
  2165. u32 spi;
  2166. audit_buf = xfrm_audit_start("SA-notfound");
  2167. if (audit_buf == NULL)
  2168. return;
  2169. xfrm_audit_helper_pktinfo(skb, family, audit_buf);
  2170. spi = ntohl(net_spi);
  2171. audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
  2172. spi, spi, ntohl(net_seq));
  2173. audit_log_end(audit_buf);
  2174. }
  2175. EXPORT_SYMBOL_GPL(xfrm_audit_state_notfound);
  2176. void xfrm_audit_state_icvfail(struct xfrm_state *x,
  2177. struct sk_buff *skb, u8 proto)
  2178. {
  2179. struct audit_buffer *audit_buf;
  2180. __be32 net_spi;
  2181. __be32 net_seq;
  2182. audit_buf = xfrm_audit_start("SA-icv-failure");
  2183. if (audit_buf == NULL)
  2184. return;
  2185. xfrm_audit_helper_pktinfo(skb, x->props.family, audit_buf);
  2186. if (xfrm_parse_spi(skb, proto, &net_spi, &net_seq) == 0) {
  2187. u32 spi = ntohl(net_spi);
  2188. audit_log_format(audit_buf, " spi=%u(0x%x) seqno=%u",
  2189. spi, spi, ntohl(net_seq));
  2190. }
  2191. audit_log_end(audit_buf);
  2192. }
  2193. EXPORT_SYMBOL_GPL(xfrm_audit_state_icvfail);
  2194. #endif /* CONFIG_AUDITSYSCALL */