linux/net/ipv4/ah4.c

// SPDX-License-Identifier: GPL-2.0-only
#define pr_fmt(fmt) …

#include <crypto/hash.h>
#include <crypto/utils.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <net/ip.h>
#include <net/xfrm.h>
#include <net/ah.h>
#include <linux/crypto.h>
#include <linux/pfkeyv2.h>
#include <linux/scatterlist.h>
#include <net/icmp.h>
#include <net/protocol.h>

struct ah_skb_cb { … };

#define AH_SKB_CB(__skb) …

static void *ah_alloc_tmp(struct crypto_ahash *ahash, int nfrags,
			  unsigned int size)
{ … }

static inline u8 *ah_tmp_auth(void *tmp, unsigned int offset)
{ … }

static inline u8 *ah_tmp_icv(void *tmp, unsigned int offset)
{ … }

static inline struct ahash_request *ah_tmp_req(struct crypto_ahash *ahash,
					       u8 *icv)
{ … }

static inline struct scatterlist *ah_req_sg(struct crypto_ahash *ahash,
					     struct ahash_request *req)
{ … }

/* Clear mutable options and find final destination to substitute
 * into IP header for icv calculation. Options are already checked
 * for validity, so paranoia is not required. */

static int ip_clear_mutable_options(const struct iphdr *iph, __be32 *daddr)
{ … }

static void ah_output_done(void *data, int err)
{ … }

static int ah_output(struct xfrm_state *x, struct sk_buff *skb)
{ … }

static void ah_input_done(void *data, int err)
{ … }

static int ah_input(struct xfrm_state *x, struct sk_buff *skb)
{ … }

static int ah4_err(struct sk_buff *skb, u32 info)
{ … }

static int ah_init_state(struct xfrm_state *x, struct netlink_ext_ack *extack)
{ … }

static void ah_destroy(struct xfrm_state *x)
{ … }

static int ah4_rcv_cb(struct sk_buff *skb, int err)
{ … }

static const struct xfrm_type ah_type = …;

static struct xfrm4_protocol ah4_protocol = …;

static int __init ah4_init(void)
{ … }

static void __exit ah4_fini(void)
{ … }

module_init(…) …;
module_exit(ah4_fini);
MODULE_DESCRIPTION(…) …;
MODULE_LICENSE(…) …;
MODULE_ALIAS_XFRM_TYPE(…);