static inline int event2poltype(int event)
 {
        switch (event) {
-       case XFRM_SAP_DELETED:
+       case XFRM_MSG_DELPOLICY:
                return SADB_X_SPDDELETE;
-       case XFRM_SAP_ADDED:
+       case XFRM_MSG_NEWPOLICY:
                return SADB_X_SPDADD;
-       case XFRM_SAP_UPDATED:
+       case XFRM_MSG_UPDPOLICY:
                return SADB_X_SPDUPDATE;
-       case XFRM_SAP_EXPIRED:
+       case XFRM_MSG_POLEXPIRE:
        //      return SADB_X_SPDEXPIRE;
        default:
                printk("pfkey: Unknown policy event %d\n", event);
 static inline int event2keytype(int event)
 {
        switch (event) {
-       case XFRM_SAP_DELETED:
+       case XFRM_MSG_DELSA:
                return SADB_DELETE;
-       case XFRM_SAP_ADDED:
+       case XFRM_MSG_NEWSA:
                return SADB_ADD;
-       case XFRM_SAP_UPDATED:
+       case XFRM_MSG_UPDSA:
                return SADB_UPDATE;
-       case XFRM_SAP_EXPIRED:
+       case XFRM_MSG_EXPIRE:
                return SADB_EXPIRE;
        default:
                printk("pfkey: Unknown SA event %d\n", event);
        struct sadb_msg *hdr;
        int hsc = 3;
 
-       if (c->event == XFRM_SAP_DELETED)
+       if (c->event == XFRM_MSG_DELSA)
                hsc = 0;
 
        skb = pfkey_xfrm_state2msg(x, 0, hsc);
        }
 
        if (hdr->sadb_msg_type == SADB_ADD)
-               c.event = XFRM_SAP_ADDED;
+               c.event = XFRM_MSG_NEWSA;
        else
-               c.event = XFRM_SAP_UPDATED;
+               c.event = XFRM_MSG_UPDSA;
        c.seq = hdr->sadb_msg_seq;
        c.pid = hdr->sadb_msg_pid;
        km_state_notify(x, &c);
 
        c.seq = hdr->sadb_msg_seq;
        c.pid = hdr->sadb_msg_pid;
-       c.event = XFRM_SAP_DELETED;
+       c.event = XFRM_MSG_DELSA;
        km_state_notify(x, &c);
        xfrm_state_put(x);
 
        c.data.proto = proto;
        c.seq = hdr->sadb_msg_seq;
        c.pid = hdr->sadb_msg_pid;
-       c.event = XFRM_SAP_FLUSHED;
+       c.event = XFRM_MSG_FLUSHSA;
        km_state_notify(NULL, &c);
 
        return 0;
        out_hdr = (struct sadb_msg *) out_skb->data;
        out_hdr->sadb_msg_version = PF_KEY_V2;
 
-       if (c->data.byid && c->event == XFRM_SAP_DELETED)
+       if (c->data.byid && c->event == XFRM_MSG_DELPOLICY)
                out_hdr->sadb_msg_type = SADB_X_SPDDELETE2;
        else
                out_hdr->sadb_msg_type = event2poltype(c->event);
        }
 
        if (hdr->sadb_msg_type == SADB_X_SPDUPDATE)
-               c.event = XFRM_SAP_UPDATED;
-       else
-               c.event = XFRM_SAP_ADDED;
+               c.event = XFRM_MSG_UPDPOLICY;
+       else 
+               c.event = XFRM_MSG_NEWPOLICY;
 
        c.seq = hdr->sadb_msg_seq;
        c.pid = hdr->sadb_msg_pid;
 
        c.seq = hdr->sadb_msg_seq;
        c.pid = hdr->sadb_msg_pid;
-       c.event = XFRM_SAP_DELETED;
+       c.event = XFRM_MSG_DELPOLICY;
        km_policy_notify(xp, pol->sadb_x_policy_dir-1, &c);
 
        xfrm_pol_put(xp);
        c.pid = hdr->sadb_msg_pid;
        if (hdr->sadb_msg_type == SADB_X_SPDDELETE2) {
                c.data.byid = 1;
-               c.event = XFRM_SAP_DELETED;
+               c.event = XFRM_MSG_DELPOLICY;
                km_policy_notify(xp, pol->sadb_x_policy_dir-1, &c);
        } else {
                err = key_pol_get_resp(sk, xp, hdr, pol->sadb_x_policy_dir-1);
        struct km_event c;
 
        xfrm_policy_flush();
-       c.event = XFRM_SAP_FLUSHED;
+       c.event = XFRM_MSG_FLUSHPOLICY;
        c.pid = hdr->sadb_msg_pid;
        c.seq = hdr->sadb_msg_seq;
        km_policy_notify(NULL, 0, &c);
 static int pfkey_send_notify(struct xfrm_state *x, struct km_event *c)
 {
        switch (c->event) {
-       case XFRM_SAP_EXPIRED:
+       case XFRM_MSG_EXPIRE:
                return key_notify_sa_expire(x, c);
-       case XFRM_SAP_DELETED:
-       case XFRM_SAP_ADDED:
-       case XFRM_SAP_UPDATED:
+       case XFRM_MSG_DELSA:
+       case XFRM_MSG_NEWSA:
+       case XFRM_MSG_UPDSA:
                return key_notify_sa(x, c);
-       case XFRM_SAP_FLUSHED:
+       case XFRM_MSG_FLUSHSA:
                return key_notify_sa_flush(c);
        default:
                printk("pfkey: Unknown SA event %d\n", c->event);
 static int pfkey_send_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c)
 {
        switch (c->event) {
-       case XFRM_SAP_EXPIRED:
+       case XFRM_MSG_POLEXPIRE:
                return key_notify_policy_expire(xp, c);
-       case XFRM_SAP_DELETED:
-       case XFRM_SAP_ADDED:
-       case XFRM_SAP_UPDATED:
+       case XFRM_MSG_DELPOLICY:
+       case XFRM_MSG_NEWPOLICY:
+       case XFRM_MSG_UPDPOLICY:
                return key_notify_policy(xp, dir, c);
-       case XFRM_SAP_FLUSHED:
+       case XFRM_MSG_FLUSHPOLICY:
                return key_notify_policy_flush(c);
        default:
                printk("pfkey: Unknown policy event %d\n", c->event);
 
 
        c.seq = nlh->nlmsg_seq;
        c.pid = nlh->nlmsg_pid;
-       if (nlh->nlmsg_type == XFRM_MSG_NEWSA)
-               c.event = XFRM_SAP_ADDED;
-       else
-               c.event = XFRM_SAP_UPDATED;
+       c.event = nlh->nlmsg_type;
 
        km_state_notify(x, &c);
        xfrm_state_put(x);
 
        c.seq = nlh->nlmsg_seq;
        c.pid = nlh->nlmsg_pid;
-       c.event = XFRM_SAP_DELETED;
+       c.event = nlh->nlmsg_type;
        km_state_notify(x, &c);
        xfrm_state_put(x);
 
                return err;
        }
 
-       if (!excl)
-               c.event = XFRM_SAP_UPDATED;
-       else
-               c.event = XFRM_SAP_ADDED;
-
+       c.event = nlh->nlmsg_type;
        c.seq = nlh->nlmsg_seq;
        c.pid = nlh->nlmsg_pid;
        km_policy_notify(xp, p->dir, &c);
                }
        } else {
                c.data.byid = p->index;
-               c.event = XFRM_SAP_DELETED;
+               c.event = nlh->nlmsg_type;
                c.seq = nlh->nlmsg_seq;
                c.pid = nlh->nlmsg_pid;
                km_policy_notify(xp, p->dir, &c);
 
        xfrm_state_flush(p->proto);
        c.data.proto = p->proto;
-       c.event = XFRM_SAP_FLUSHED;
+       c.event = nlh->nlmsg_type;
        c.seq = nlh->nlmsg_seq;
        c.pid = nlh->nlmsg_pid;
        km_state_notify(NULL, &c);
        struct km_event c;
 
        xfrm_policy_flush();
-       c.event = XFRM_SAP_FLUSHED;
+       c.event = nlh->nlmsg_type;
        c.seq = nlh->nlmsg_seq;
        c.pid = nlh->nlmsg_pid;
        km_policy_notify(NULL, 0, &c);
        struct xfrm_usersa_info *p;
        struct nlmsghdr *nlh;
        struct sk_buff *skb;
-       u32 nlt;
        unsigned char *b;
        int len = xfrm_sa_len(x);
 
                return -ENOMEM;
        b = skb->tail;
 
-       if (c->event == XFRM_SAP_ADDED)
-               nlt = XFRM_MSG_NEWSA;
-       else if (c->event == XFRM_SAP_UPDATED)
-               nlt = XFRM_MSG_UPDSA;
-       else if (c->event == XFRM_SAP_DELETED)
-               nlt = XFRM_MSG_DELSA;
-       else
-               goto nlmsg_failure;
-
-       nlh = NLMSG_PUT(skb, c->pid, c->seq, nlt, sizeof(*p));
+       nlh = NLMSG_PUT(skb, c->pid, c->seq, c->event, sizeof(*p));
        nlh->nlmsg_flags = 0;
 
        p = NLMSG_DATA(nlh);
 {
 
        switch (c->event) {
-       case XFRM_SAP_EXPIRED:
+       case XFRM_MSG_EXPIRE:
                return xfrm_exp_state_notify(x, c);
-       case XFRM_SAP_DELETED:
-       case XFRM_SAP_UPDATED:
-       case XFRM_SAP_ADDED:
+       case XFRM_MSG_DELSA:
+       case XFRM_MSG_UPDSA:
+       case XFRM_MSG_NEWSA:
                return xfrm_notify_sa(x, c);
-       case XFRM_SAP_FLUSHED:
+       case XFRM_MSG_FLUSHSA:
                return xfrm_notify_sa_flush(c);
        default:
                 printk("xfrm_user: Unknown SA event %d\n", c->event);
        struct xfrm_userpolicy_info *p;
        struct nlmsghdr *nlh;
        struct sk_buff *skb;
-       u32 nlt = 0 ;
        unsigned char *b;
        int len = RTA_SPACE(sizeof(struct xfrm_user_tmpl) * xp->xfrm_nr);
        len += NLMSG_SPACE(sizeof(struct xfrm_userpolicy_info));
                return -ENOMEM;
        b = skb->tail;
 
-       if (c->event == XFRM_SAP_ADDED)
-               nlt = XFRM_MSG_NEWPOLICY;
-       else if (c->event == XFRM_SAP_UPDATED)
-               nlt = XFRM_MSG_UPDPOLICY;
-       else if (c->event == XFRM_SAP_DELETED)
-               nlt = XFRM_MSG_DELPOLICY;
-       else
-               goto nlmsg_failure;
-
-       nlh = NLMSG_PUT(skb, c->pid, c->seq, nlt, sizeof(*p));
+       nlh = NLMSG_PUT(skb, c->pid, c->seq, c->event, sizeof(*p));
 
        p = NLMSG_DATA(nlh);
 
 {
 
        switch (c->event) {
-       case XFRM_SAP_ADDED:
-       case XFRM_SAP_UPDATED:
-       case XFRM_SAP_DELETED:
+       case XFRM_MSG_NEWPOLICY:
+       case XFRM_MSG_UPDPOLICY:
+       case XFRM_MSG_DELPOLICY:
                return xfrm_notify_policy(xp, dir, c);
-       case XFRM_SAP_FLUSHED:
+       case XFRM_MSG_FLUSHPOLICY:
                return xfrm_notify_policy_flush(c);
-       case XFRM_SAP_EXPIRED:
+       case XFRM_MSG_POLEXPIRE:
                return xfrm_exp_policy_notify(xp, dir, c);
        default:
                printk("xfrm_user: Unknown Policy event %d\n", c->event);