source: rtems-libbsd/ipsec-tools/src/racoon/isakmp.c @ 8645c9d7

5-freebsd-12
Last change on this file since 8645c9d7 was 8645c9d7, checked in by Christian Mauderer <christian.mauderer@…>, on Jun 6, 2018 at 9:11:52 AM

ipsec-tools: Apply patches from FreeBSD ports.

Source: https://svnweb.freebsd.org/ports/head/security/ipsec-tools/files/ revision 468617.

  • Property mode set to 100644
File size: 85.8 KB
Line 
1/*      $NetBSD: isakmp.c,v 1.71.2.2 2012/08/29 08:55:26 tteras Exp $   */
2
3/* Id: isakmp.c,v 1.74 2006/05/07 21:32:59 manubsd Exp */
4
5/*
6 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 *    notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 *    notice, this list of conditions and the following disclaimer in the
16 *    documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the project nor the names of its contributors
18 *    may be used to endorse or promote products derived from this software
19 *    without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 * SUCH DAMAGE.
32 */
33
34#include "config.h"
35
36#include <sys/types.h>
37#include <sys/param.h>
38#include <sys/socket.h>
39#include <sys/queue.h>
40
41#include <netinet/in.h>
42#include <arpa/inet.h>
43
44#include PATH_IPSEC_H
45
46#include <stdlib.h>
47#include <stdio.h>
48#include <string.h>
49#include <errno.h>
50#if TIME_WITH_SYS_TIME
51# include <sys/time.h>
52# include <time.h>
53#else
54# if HAVE_SYS_TIME_H
55#  include <sys/time.h>
56# else
57#  include <time.h>
58# endif
59#endif
60#include <netdb.h>
61#ifdef HAVE_UNISTD_H
62#include <unistd.h>
63#endif
64#include <ctype.h>
65#ifdef ENABLE_HYBRID
66#include <resolv.h>
67#endif
68
69#include "var.h"
70#include "misc.h"
71#include "vmbuf.h"
72#include "plog.h"
73#include "sockmisc.h"
74#include "schedule.h"
75#include "session.h"
76#include "debug.h"
77
78#include "remoteconf.h"
79#include "localconf.h"
80#include "grabmyaddr.h"
81#include "admin.h"
82#include "privsep.h"
83#include "isakmp_var.h"
84#include "isakmp.h"
85#include "oakley.h"
86#include "evt.h"
87#include "handler.h"
88#include "ipsec_doi.h"
89#include "pfkey.h"
90#include "crypto_openssl.h"
91#include "policy.h"
92#include "algorithm.h"
93#include "proposal.h"
94#include "sainfo.h"
95#include "isakmp_ident.h"
96#include "isakmp_agg.h"
97#include "isakmp_base.h"
98#include "isakmp_quick.h"
99#include "isakmp_inf.h"
100#include "isakmp_newg.h"
101#ifdef ENABLE_HYBRID
102#include "vendorid.h"
103#include "isakmp_xauth.h"
104#include "isakmp_unity.h"
105#include "isakmp_cfg.h"
106#endif
107#ifdef ENABLE_FRAG
108#include "isakmp_frag.h"
109#endif
110#include "strnames.h"
111
112#include <fcntl.h>
113
114#ifdef ENABLE_NATT
115# include "nattraversal.h"
116#endif
117# ifdef __linux__
118#  include <linux/udp.h>
119#  include <linux/ip.h>
120#  ifndef SOL_UDP
121#   define SOL_UDP 17
122#  endif
123# endif /* __linux__ */
124# if defined(__NetBSD__) || defined(__FreeBSD__) ||     \
125  (defined(__APPLE__) && defined(__MACH__))
126#  include <netinet/in.h>
127#  include <netinet/udp.h>
128#  include <netinet/in_systm.h>
129#  include <netinet/ip.h>
130#  define SOL_UDP IPPROTO_UDP
131# endif /* __NetBSD__ / __FreeBSD__ */
132
133static int nostate1 __P((struct ph1handle *, vchar_t *));
134static int nostate2 __P((struct ph2handle *, vchar_t *));
135
136extern caddr_t val2str(const char *, size_t);
137
138static int (*ph1exchange[][2][PHASE1ST_MAX])
139        __P((struct ph1handle *, vchar_t *)) = {
140 /* error */
141 { { 0 }, { 0 }, },
142 /* Identity Protection exchange */
143 {
144  { nostate1, ident_i1send, nostate1, ident_i2recv, ident_i2send,
145    ident_i3recv, ident_i3send, ident_i4recv, ident_i4send, nostate1, nostate1,},
146  { nostate1, ident_r1recv, ident_r1send, ident_r2recv, ident_r2send,
147    ident_r3recv, ident_r3send, nostate1, nostate1, nostate1, nostate1, },
148 },
149 /* Aggressive exchange */
150 {
151  { nostate1, agg_i1send, nostate1, agg_i2recv, agg_i2send,
152    nostate1, nostate1, nostate1, nostate1, nostate1, nostate1, },
153  { nostate1, agg_r1recv, agg_r1send, agg_r2recv, agg_r2send,
154    nostate1, nostate1, nostate1, nostate1, nostate1, nostate1, },
155 },
156 /* Base exchange */
157 {
158  { nostate1, base_i1send, nostate1, base_i2recv, base_i2send,
159    base_i3recv, base_i3send, nostate1, nostate1, nostate1, nostate1, },
160  { nostate1, base_r1recv, base_r1send, base_r2recv, base_r2send,
161    nostate1, nostate1, nostate1, nostate1, nostate1, nostate1, },
162 },
163};
164
165static int (*ph2exchange[][2][PHASE2ST_MAX])
166        __P((struct ph2handle *, vchar_t *)) = {
167 /* error */
168 { { 0 }, { 0 }, },
169 /* Quick mode for IKE */
170 {
171  { nostate2, nostate2, quick_i1prep, nostate2, quick_i1send,
172    quick_i2recv, quick_i2send, quick_i3recv, nostate2, nostate2, },
173  { nostate2, quick_r1recv, quick_r1prep, nostate2, quick_r2send,
174    quick_r3recv, quick_r3prep, quick_r3send, nostate2, nostate2, }
175 },
176};
177
178static u_char r_ck0[] = { 0,0,0,0,0,0,0,0 }; /* used to verify the r_ck. */
179
180static int isakmp_main __P((vchar_t *, struct sockaddr *, struct sockaddr *));
181static int ph1_main __P((struct ph1handle *, vchar_t *));
182static int quick_main __P((struct ph2handle *, vchar_t *));
183static int isakmp_ph1begin_r __P((vchar_t *,
184        struct sockaddr *, struct sockaddr *, u_int8_t));
185static int isakmp_ph2begin_i __P((struct ph1handle *, struct ph2handle *));
186static int isakmp_ph2begin_r __P((struct ph1handle *, vchar_t *));
187static int etypesw1 __P((int));
188static int etypesw2 __P((int));
189static int isakmp_ph1resend __P((struct ph1handle *));
190static int isakmp_ph2resend __P((struct ph2handle *));
191
192#ifdef ENABLE_FRAG
193static int frag_handler(struct ph1handle *,
194    vchar_t *, struct sockaddr *, struct sockaddr *);
195#endif
196
197/*
198 * isakmp packet handler
199 */
200static int
201isakmp_handler(ctx, so_isakmp)
202        void *ctx;
203        int so_isakmp;
204{
205        struct isakmp isakmp;
206        union {
207                char            buf[sizeof (isakmp) + 4];
208                u_int32_t       non_esp[2];
209                struct          {
210                                     struct udphdr udp;
211#ifdef __linux
212                                     struct iphdr ip;
213#else
214                                     struct ip ip;
215#endif
216                                     char buf[sizeof(isakmp) + 4];
217                                } lbuf;
218        } x;
219        struct sockaddr_storage remote;
220        struct sockaddr_storage local;
221        unsigned int remote_len = sizeof(remote);
222        unsigned int local_len = sizeof(local);
223        int len = 0, extralen = 0;
224        vchar_t *buf = NULL, *tmpbuf = NULL;
225        int error = -1, res;
226
227        /* read message by MSG_PEEK */
228        while ((len = recvfromto(so_isakmp, x.buf, sizeof(x),
229                    MSG_PEEK, (struct sockaddr *)&remote, &remote_len,
230                    (struct sockaddr *)&local, &local_len)) < 0) {
231                if (errno == EINTR)
232                        continue;
233                plog(LLV_ERROR, LOCATION, NULL,
234                        "failed to receive isakmp packet: %s\n",
235                        strerror (errno));
236                goto end;
237        }
238
239        /* keep-alive packet - ignore */
240        if (len == 1 && (x.buf[0]&0xff) == 0xff) {
241                /* Pull the keep-alive packet */
242                if ((len = recvfrom(so_isakmp, (char *)x.buf, 1,
243                    0, (struct sockaddr *)&remote, &remote_len)) != 1) {
244                        plog(LLV_ERROR, LOCATION, NULL,
245                            "failed to receive keep alive packet: %s\n",
246                            strerror (errno));
247                }
248                goto end;
249        }
250
251        /* Lucent IKE in UDP encapsulation */
252        {
253#ifdef __linux__
254                if (ntohs(x.lbuf.udp.dest) == 501) {
255                        extralen += sizeof(x.lbuf.udp) + x.lbuf.ip.ihl;
256                }
257#else
258                if (ntohs(x.lbuf.udp.uh_dport) == 501) {
259                        extralen += sizeof(x.lbuf.udp) + x.lbuf.ip.ip_hl;
260                }
261#endif
262        }
263
264#ifdef ENABLE_NATT
265        /* we don't know about portchange yet,
266           look for non-esp marker instead */
267        if (x.non_esp[0] == 0 && x.non_esp[1] != 0)
268                extralen = NON_ESP_MARKER_LEN;
269#endif
270
271        /* now we know if there is an extra non-esp
272           marker at the beginning or not */
273        memcpy ((char *)&isakmp, x.buf + extralen, sizeof (isakmp));
274
275        /* check isakmp header length, as well as sanity of header length */
276        if (len < sizeof(isakmp) || ntohl(isakmp.len) < sizeof(isakmp)) {
277                plog(LLV_ERROR, LOCATION, (struct sockaddr *)&remote,
278                        "packet shorter than isakmp header size (%u, %u, %zu)\n",
279                        len, ntohl(isakmp.len), sizeof(isakmp));
280                /* dummy receive */
281                if ((len = recvfrom(so_isakmp, (char *)&isakmp, sizeof(isakmp),
282                            0, (struct sockaddr *)&remote, &remote_len)) < 0) {
283                        plog(LLV_ERROR, LOCATION, NULL,
284                                "failed to receive isakmp packet: %s\n",
285                                strerror (errno));
286                }
287                goto end;
288        }
289
290        /* reject it if the size is tooooo big. */
291        if (ntohl(isakmp.len) > 0xffff) {
292                plog(LLV_ERROR, LOCATION, NULL,
293                        "the length in the isakmp header is too big.\n");
294                if ((len = recvfrom(so_isakmp, (char *)&isakmp, sizeof(isakmp),
295                            0, (struct sockaddr *)&remote, &remote_len)) < 0) {
296                        plog(LLV_ERROR, LOCATION, NULL,
297                                "failed to receive isakmp packet: %s\n",
298                                strerror (errno));
299                }
300                goto end;
301        }
302
303        /* read real message */
304        if ((tmpbuf = vmalloc(ntohl(isakmp.len) + extralen)) == NULL) {
305                plog(LLV_ERROR, LOCATION, NULL,
306                        "failed to allocate reading buffer (%u Bytes)\n",
307                        ntohl(isakmp.len) + extralen);
308                /* dummy receive */
309                if ((len = recvfrom(so_isakmp, (char *)&isakmp, sizeof(isakmp),
310                            0, (struct sockaddr *)&remote, &remote_len)) < 0) {
311                        plog(LLV_ERROR, LOCATION, NULL,
312                                "failed to receive isakmp packet: %s\n",
313                                strerror (errno));
314                }
315                goto end;
316        }
317
318        while ((len = recvfromto(so_isakmp, (char *)tmpbuf->v, tmpbuf->l,
319                            0, (struct sockaddr *)&remote, &remote_len,
320                            (struct sockaddr *)&local, &local_len)) < 0) {
321                if (errno == EINTR)
322                        continue;
323                plog(LLV_ERROR, LOCATION, NULL,
324                        "failed to receive isakmp packet: %s\n",
325                        strerror (errno));
326                goto end;
327        }
328
329        if ((buf = vmalloc(len - extralen)) == NULL) {
330                plog(LLV_ERROR, LOCATION, NULL,
331                        "failed to allocate reading buffer (%u Bytes)\n",
332                        (len - extralen));
333                goto end;
334        }
335
336        memcpy (buf->v, tmpbuf->v + extralen, buf->l);
337
338        len -= extralen;
339
340        if (len != buf->l) {
341                plog(LLV_ERROR, LOCATION, (struct sockaddr *)&remote,
342                        "received invalid length (%d != %zu), why ?\n",
343                        len, buf->l);
344                goto end;
345        }
346
347        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
348        plog(LLV_DEBUG, LOCATION, NULL,
349                "%d bytes message received %s\n",
350                len, saddr2str_fromto("from %s to %s",
351                        (struct sockaddr *)&remote,
352                        (struct sockaddr *)&local));
353        plogdump(LLV_DEBUG, buf->v, buf->l);
354
355        /* avoid packets with malicious port/address */
356        if (extract_port((struct sockaddr *)&remote) == 0) {
357                plog(LLV_ERROR, LOCATION, (struct sockaddr *)&remote,
358                        "src port == 0 (valid as UDP but not with IKE)\n");
359                goto end;
360        }
361
362        /* XXX: check sender whether to be allowed or not to accept */
363
364        /* XXX: I don't know how to check isakmp half connection attack. */
365
366        /* simply reply if the packet was processed. */
367        res=check_recvdpkt((struct sockaddr *)&remote,(struct sockaddr *)&local, buf);
368        if (res) {
369                plog(LLV_NOTIFY, LOCATION, NULL,
370                        "the packet is retransmitted by %s (%d).\n",
371                         saddr2str((struct sockaddr *)&remote), res);
372                error = 0;
373                goto end;
374        }
375
376        /* isakmp main routine */
377        if (isakmp_main(buf, (struct sockaddr *)&remote,
378                        (struct sockaddr *)&local) != 0) goto end;
379
380        error = 0;
381
382end:
383        if (tmpbuf != NULL)
384                vfree(tmpbuf);
385        if (buf != NULL)
386                vfree(buf);
387        return error;
388}
389
390/*
391 * main processing to handle isakmp payload
392 */
393static int
394isakmp_main(msg, remote, local)
395        vchar_t *msg;
396        struct sockaddr *remote, *local;
397{
398        struct isakmp *isakmp = (struct isakmp *)msg->v;
399        isakmp_index *index = (isakmp_index *)isakmp;
400        u_int32_t msgid = isakmp->msgid;
401        struct ph1handle *iph1;
402
403#ifdef HAVE_PRINT_ISAKMP_C
404        isakmp_printpacket(msg, remote, local, 0);
405#endif
406
407        /* the initiator's cookie must not be zero */
408        if (memcmp(&isakmp->i_ck, r_ck0, sizeof(cookie_t)) == 0) {
409                plog(LLV_ERROR, LOCATION, remote,
410                        "malformed cookie received.\n");
411                return -1;
412        }
413
414        /* Check the Major and Minor Version fields. */
415        /*
416         * XXX Is is right to check version here ?
417         * I think it may no be here because the version depends
418         * on exchange status.
419         */
420        if (isakmp->v < ISAKMP_VERSION_NUMBER) {
421                if (ISAKMP_GETMAJORV(isakmp->v) < ISAKMP_MAJOR_VERSION) {
422                        plog(LLV_ERROR, LOCATION, remote,
423                                "invalid major version %d.\n",
424                                ISAKMP_GETMAJORV(isakmp->v));
425                        return -1;
426                }
427#if ISAKMP_MINOR_VERSION > 0
428                if (ISAKMP_GETMINORV(isakmp->v) < ISAKMP_MINOR_VERSION) {
429                        plog(LLV_ERROR, LOCATION, remote,
430                                "invalid minor version %d.\n",
431                                ISAKMP_GETMINORV(isakmp->v));
432                        return -1;
433                }
434#endif
435        }
436
437        /* check the Flags field. */
438        /* XXX How is the exclusive check, E and A ? */
439        if (isakmp->flags & ~(ISAKMP_FLAG_E | ISAKMP_FLAG_C | ISAKMP_FLAG_A)) {
440                plog(LLV_ERROR, LOCATION, remote,
441                        "invalid flag 0x%02x.\n", isakmp->flags);
442                return -1;
443        }
444
445        /* ignore commit bit. */
446        if (ISSET(isakmp->flags, ISAKMP_FLAG_C)) {
447                if (isakmp->msgid == 0) {
448                        isakmp_info_send_nx(isakmp, remote, local,
449                                ISAKMP_NTYPE_INVALID_FLAGS, NULL);
450                        plog(LLV_ERROR, LOCATION, remote,
451                                "Commit bit on phase1 forbidden.\n");
452                        return -1;
453                }
454        }
455
456        iph1 = getph1byindex(index);
457        if (iph1 != NULL) {
458                /* validity check */
459                if (memcmp(&isakmp->r_ck, r_ck0, sizeof(cookie_t)) == 0 &&
460                    iph1->side == INITIATOR) {
461                        plog(LLV_DEBUG, LOCATION, remote,
462                                "malformed cookie received or "
463                                "the initiator's cookies collide.\n");
464                        return -1;
465                }
466
467#ifdef ENABLE_NATT
468                /* Floating ports for NAT-T */
469                if (NATT_AVAILABLE(iph1) &&
470                    ! (iph1->natt_flags & NAT_PORTS_CHANGED) &&
471                    ((cmpsaddr(iph1->remote, remote) != CMPSADDR_MATCH) ||
472                     (cmpsaddr(iph1->local, local) != CMPSADDR_MATCH)))
473                {
474                        /* prevent memory leak */
475                        racoon_free(iph1->remote);
476                        racoon_free(iph1->local);
477                        iph1->remote = NULL;
478                        iph1->local = NULL;
479
480                        /* copy-in new addresses */
481                        iph1->remote = dupsaddr(remote);
482                        if (iph1->remote == NULL) {
483                                plog(LLV_ERROR, LOCATION, iph1->remote,
484                                   "phase1 failed: dupsaddr failed.\n");
485                                remph1(iph1);
486                                delph1(iph1);
487                                return -1;
488                        }
489                        iph1->local = dupsaddr(local);
490                        if (iph1->local == NULL) {
491                                plog(LLV_ERROR, LOCATION, iph1->remote,
492                                   "phase1 failed: dupsaddr failed.\n");
493                                remph1(iph1);
494                                delph1(iph1);
495                                return -1;
496                        }
497
498                        /* set the flag to prevent further port floating
499                           (FIXME: should we allow it? E.g. when the NAT gw
500                            is rebooted?) */
501                        iph1->natt_flags |= NAT_PORTS_CHANGED | NAT_ADD_NON_ESP_MARKER;
502
503                        /* print some neat info */
504                        plog (LLV_INFO, LOCATION, NULL,
505                              "NAT-T: ports changed to: %s\n",
506                              saddr2str_fromto ("%s<->%s", iph1->remote, iph1->local));
507
508                        natt_keepalive_add_ph1 (iph1);
509                }
510#endif
511
512                /* must be same addresses in one stream of a phase at least. */
513                if (cmpsaddr(iph1->remote, remote) != CMPSADDR_MATCH) {
514                        char *saddr_db, *saddr_act;
515
516                        saddr_db = racoon_strdup(saddr2str(iph1->remote));
517                        saddr_act = racoon_strdup(saddr2str(remote));
518                        STRDUP_FATAL(saddr_db);
519                        STRDUP_FATAL(saddr_act);
520
521                        plog(LLV_WARNING, LOCATION, remote,
522                                "remote address mismatched. db=%s, act=%s\n",
523                                saddr_db, saddr_act);
524
525                        racoon_free(saddr_db);
526                        racoon_free(saddr_act);
527                }
528
529                /*
530                 * don't check of exchange type here because other type will be
531                 * with same index, for example, informational exchange.
532                 */
533
534                /* XXX more acceptable check */
535        }
536
537        switch (isakmp->etype) {
538        case ISAKMP_ETYPE_IDENT:
539        case ISAKMP_ETYPE_AGG:
540        case ISAKMP_ETYPE_BASE:
541                /* phase 1 validity check */
542                if (isakmp->msgid != 0) {
543                        plog(LLV_ERROR, LOCATION, remote,
544                                "message id should be zero in phase1.\n");
545                        return -1;
546                }
547
548                /* search for isakmp status record of phase 1 */
549                if (iph1 == NULL) {
550                        /*
551                         * the packet must be the 1st message from a initiator
552                         * or the 2nd message from the responder.
553                         */
554
555                        /* search for phase1 handle by index without r_ck */
556                        iph1 = getph1byindex0(index);
557                        if (iph1 == NULL) {
558                                /*it must be the 1st message from a initiator.*/
559                                if (memcmp(&isakmp->r_ck, r_ck0,
560                                        sizeof(cookie_t)) != 0) {
561
562                                        plog(LLV_DEBUG, LOCATION, remote,
563                                                "malformed cookie received "
564                                                "or the spi expired.\n");
565                                        return -1;
566                                }
567
568                                /* it must be responder's 1st exchange. */
569                                if (isakmp_ph1begin_r(msg, remote, local,
570                                        isakmp->etype) < 0)
571                                        return -1;
572                                break;
573
574                                /*NOTREACHED*/
575                        }
576
577                        /* it must be the 2nd message from the responder. */
578                        if (iph1->side != INITIATOR) {
579                                plog(LLV_DEBUG, LOCATION, remote,
580                                        "malformed cookie received. "
581                                        "it has to be as the initiator.  %s\n",
582                                        isakmp_pindex(&iph1->index, 0));
583                                return -1;
584                        }
585                }
586
587                /*
588                 * Don't delete phase 1 handler when the exchange type
589                 * in handler is not equal to packet's one because of no
590                 * authencication completed.
591                 */
592                if (iph1->etype != isakmp->etype) {
593                        plog(LLV_ERROR, LOCATION, iph1->remote,
594                                "exchange type is mismatched: "
595                                "db=%s packet=%s, ignore it.\n",
596                                s_isakmp_etype(iph1->etype),
597                                s_isakmp_etype(isakmp->etype));
598                        return -1;
599                }
600
601#ifdef ENABLE_FRAG
602                if (isakmp->np == ISAKMP_NPTYPE_FRAG)
603                        return frag_handler(iph1, msg, remote, local);
604#endif
605
606                /* call main process of phase 1 */
607                if (ph1_main(iph1, msg) < 0) {
608                        plog(LLV_ERROR, LOCATION, iph1->remote,
609                                "phase1 negotiation failed.\n");
610                        remph1(iph1);
611                        delph1(iph1);
612                        return -1;
613                }
614                break;
615
616        case ISAKMP_ETYPE_AUTH:
617                plog(LLV_INFO, LOCATION, remote,
618                        "unsupported exchange %d received.\n",
619                        isakmp->etype);
620                break;
621
622        case ISAKMP_ETYPE_INFO:
623        case ISAKMP_ETYPE_ACKINFO:
624                /*
625                 * iph1 must be present for Information message.
626                 * if iph1 is null then trying to get the phase1 status
627                 * as the packet from responder againt initiator's 1st
628                 * exchange in phase 1.
629                 * NOTE: We think such informational exchange should be ignored.
630                 */
631                if (iph1 == NULL) {
632                        iph1 = getph1byindex0(index);
633                        if (iph1 == NULL) {
634                                plog(LLV_ERROR, LOCATION, remote,
635                                        "unknown Informational "
636                                        "exchange received.\n");
637                                return -1;
638                        }
639                        if (cmpsaddr(iph1->remote, remote) != CMPSADDR_MATCH) {
640                                plog(LLV_WARNING, LOCATION, remote,
641                                        "remote address mismatched. "
642                                        "db=%s\n",
643                                        saddr2str(iph1->remote));
644                        }
645                }
646
647#ifdef ENABLE_FRAG
648                if (isakmp->np == ISAKMP_NPTYPE_FRAG)
649                        return frag_handler(iph1, msg, remote, local);
650#endif
651
652                if (isakmp_info_recv(iph1, msg) < 0)
653                        return -1;
654                break;
655
656        case ISAKMP_ETYPE_QUICK:
657        {
658                struct ph2handle *iph2;
659
660                if (iph1 == NULL) {
661                        isakmp_info_send_nx(isakmp, remote, local,
662                                ISAKMP_NTYPE_INVALID_COOKIE, NULL);
663                        plog(LLV_ERROR, LOCATION, remote,
664                                "can't start the quick mode, "
665                                "there is no ISAKMP-SA, %s\n",
666                                isakmp_pindex((isakmp_index *)&isakmp->i_ck,
667                                        isakmp->msgid));
668                        return -1;
669                }
670#ifdef ENABLE_HYBRID
671                /* Reinit the IVM if it's still there */
672                if (iph1->mode_cfg && iph1->mode_cfg->ivm) {
673                        oakley_delivm(iph1->mode_cfg->ivm);
674                        iph1->mode_cfg->ivm = NULL;
675                }
676#endif
677#ifdef ENABLE_FRAG
678                if (isakmp->np == ISAKMP_NPTYPE_FRAG)
679                        return frag_handler(iph1, msg, remote, local);
680#endif
681
682                /* check status of phase 1 whether negotiated or not. */
683                if (iph1->status != PHASE1ST_ESTABLISHED &&
684                    iph1->status != PHASE1ST_DYING) {
685                        plog(LLV_ERROR, LOCATION, remote,
686                                "can't start the quick mode, "
687                                "there is no valid ISAKMP-SA, %s\n",
688                                isakmp_pindex(&iph1->index, iph1->msgid));
689                        return -1;
690                }
691
692                /* search isakmp phase 2 stauts record. */
693                iph2 = getph2bymsgid(iph1, msgid);
694                if (iph2 == NULL) {
695                        /* it must be new negotiation as responder */
696                        if (isakmp_ph2begin_r(iph1, msg) < 0)
697                                return -1;
698                        return 0;
699                        /*NOTREACHED*/
700                }
701
702                /* commit bit. */
703                /* XXX
704                 * we keep to set commit bit during negotiation.
705                 * When SA is configured, bit will be reset.
706                 * XXX
707                 * don't initiate commit bit.  should be fixed in the future.
708                 */
709                if (ISSET(isakmp->flags, ISAKMP_FLAG_C))
710                        iph2->flags |= ISAKMP_FLAG_C;
711
712                /* call main process of quick mode */
713                if (quick_main(iph2, msg) < 0) {
714                        plog(LLV_ERROR, LOCATION, iph1->remote,
715                                "phase2 negotiation failed.\n");
716                        remph2(iph2);
717                        delph2(iph2);
718                        return -1;
719                }
720        }
721                break;
722
723        case ISAKMP_ETYPE_NEWGRP:
724                if (iph1 == NULL) {
725                        plog(LLV_ERROR, LOCATION, remote,
726                                "Unknown new group mode exchange, "
727                                "there is no ISAKMP-SA.\n");
728                        return -1;
729                }
730
731#ifdef ENABLE_FRAG
732                if (isakmp->np == ISAKMP_NPTYPE_FRAG)
733                        return frag_handler(iph1, msg, remote, local);
734#endif
735
736                isakmp_newgroup_r(iph1, msg);
737                break;
738
739#ifdef ENABLE_HYBRID
740        case ISAKMP_ETYPE_CFG:
741                if (iph1 == NULL) {
742                        plog(LLV_ERROR, LOCATION, NULL,
743                             "mode config %d from %s, "
744                             "but we have no ISAKMP-SA.\n",
745                             isakmp->etype, saddr2str(remote));
746                        return -1;
747                }
748
749#ifdef ENABLE_FRAG
750                if (isakmp->np == ISAKMP_NPTYPE_FRAG)
751                        return frag_handler(iph1, msg, remote, local);
752#endif
753
754                isakmp_cfg_r(iph1, msg);
755                break;
756#endif
757
758        case ISAKMP_ETYPE_NONE:
759        default:
760                plog(LLV_ERROR, LOCATION, NULL,
761                        "Invalid exchange type %d from %s.\n",
762                        isakmp->etype, saddr2str(remote));
763                return -1;
764        }
765
766        return 0;
767}
768
769/*
770 * main function of phase 1.
771 */
772static int
773ph1_main(iph1, msg)
774        struct ph1handle *iph1;
775        vchar_t *msg;
776{
777        int error;
778#ifdef ENABLE_STATS
779        struct timeval start, end;
780#endif
781
782        /* ignore a packet */
783        if (iph1->status >= PHASE1ST_ESTABLISHED)
784                return 0;
785
786#ifdef ENABLE_STATS
787        gettimeofday(&start, NULL);
788#endif
789        /* receive */
790        if (ph1exchange[etypesw1(iph1->etype)]
791                       [iph1->side]
792                       [iph1->status] == NULL) {
793                plog(LLV_ERROR, LOCATION, iph1->remote,
794                        "why isn't the function defined.\n");
795                return -1;
796        }
797        error = (ph1exchange[etypesw1(iph1->etype)]
798                            [iph1->side]
799                            [iph1->status])(iph1, msg);
800        if (error != 0) {
801
802                /* XXX
803                 * When an invalid packet is received on phase1, it should
804                 * be selected to process this packet.  That is to respond
805                 * with a notify and delete phase 1 handler, OR not to respond
806                 * and keep phase 1 handler. However, in PHASE1ST_START when
807                 * acting as RESPONDER we must not keep phase 1 handler or else
808                 * it will stay forever.
809                 */
810
811                if (iph1->side == RESPONDER && iph1->status == PHASE1ST_START) {
812                        plog(LLV_ERROR, LOCATION, iph1->remote,
813                                "failed to pre-process ph1 packet (side: %d, status %d).\n",
814                                iph1->side, iph1->status);
815                        return -1;
816                } else {
817                        /* ignore the error and keep phase 1 handler */
818                        return 0;
819                }
820        }
821
822#ifndef ENABLE_FRAG
823        /* free resend buffer */
824        if (iph1->sendbuf == NULL) {
825                plog(LLV_ERROR, LOCATION, NULL,
826                        "no buffer found as sendbuf\n");
827                return -1;
828        }
829#endif
830
831        VPTRINIT(iph1->sendbuf);
832
833        /* turn off schedule */
834        sched_cancel(&iph1->scr);
835
836        /* send */
837        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
838        if ((ph1exchange[etypesw1(iph1->etype)]
839                        [iph1->side]
840                        [iph1->status])(iph1, msg) != 0) {
841                plog(LLV_ERROR, LOCATION, iph1->remote,
842                        "failed to process ph1 packet (side: %d, status: %d).\n",
843                        iph1->side, iph1->status);
844                return -1;
845        }
846
847#ifdef ENABLE_STATS
848        gettimeofday(&end, NULL);
849        syslog(LOG_NOTICE, "%s(%s): %8.6f",
850                "phase1", s_isakmp_state(iph1->etype, iph1->side, iph1->status),
851                timedelta(&start, &end));
852#endif
853        if (iph1->status == PHASE1ST_ESTABLISHED) {
854
855#ifdef ENABLE_STATS
856                gettimeofday(&iph1->end, NULL);
857                syslog(LOG_NOTICE, "%s(%s): %8.6f",
858                        "phase1", s_isakmp_etype(iph1->etype),
859                        timedelta(&iph1->start, &iph1->end));
860#endif
861
862                /* save created date. */
863                (void)time(&iph1->created);
864
865                /* migrate ph2s from dying ph1s */
866                migrate_dying_ph12(iph1);
867
868                /* add to the schedule to expire, and seve back pointer. */
869                if (ph1_rekey_enabled(iph1)) {
870                        sched_schedule(&iph1->sce,
871                                       iph1->approval->lifetime *
872                                       PFKEY_SOFT_LIFETIME_RATE / 100,
873                                       isakmp_ph1dying_stub);
874                } else {
875                        sched_schedule(&iph1->sce, iph1->approval->lifetime,
876                                       isakmp_ph1expire_stub);
877                }
878
879#ifdef ENABLE_HYBRID
880                if (iph1->mode_cfg->flags & ISAKMP_CFG_VENDORID_XAUTH) {
881                        switch (iph1->approval->authmethod) {
882                        case OAKLEY_ATTR_AUTH_METHOD_HYBRID_RSA_R:
883                        case OAKLEY_ATTR_AUTH_METHOD_HYBRID_DSS_R:
884                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_PSKEY_R:
885                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSASIG_R:
886                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_DSSSIG_R:
887                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAENC_R:
888                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAREV_R:
889                                xauth_sendreq(iph1);
890                                /* XXX Don't process INITIAL_CONTACT */
891                                iph1->rmconf->ini_contact = 0;
892                                break;
893                        default:
894                                break;
895                        }
896                }
897#endif
898#ifdef ENABLE_DPD
899                /* Schedule the r_u_there.... */
900                if(iph1->dpd_support && iph1->rmconf->dpd_interval)
901                        isakmp_sched_r_u(iph1, 0);
902#endif
903
904                /* INITIAL-CONTACT processing */
905                /* don't anything if local test mode. */
906                if (!f_local
907                 && iph1->rmconf->ini_contact && !getcontacted(iph1->remote)) {
908                        /* send INITIAL-CONTACT */
909                        isakmp_info_send_n1(iph1,
910                                        ISAKMP_NTYPE_INITIAL_CONTACT, NULL);
911                        /* insert a node into contacted list. */
912                        if (inscontacted(iph1->remote) == -1) {
913                                plog(LLV_ERROR, LOCATION, iph1->remote,
914                                        "failed to add contacted list.\n");
915                                /* ignore */
916                        }
917                }
918                if (iph1->initial_contact_received)
919                        isakmp_info_recv_initialcontact(iph1, NULL);
920
921                log_ph1established(iph1);
922                plog(LLV_DEBUG, LOCATION, NULL, "===\n");
923
924                /*
925                 * SA up shell script hook: do it now,except if
926                 * ISAKMP mode config was requested. In the later
927                 * case it is done when we receive the configuration.
928                 */
929                if ((iph1->status == PHASE1ST_ESTABLISHED) &&
930                    !iph1->rmconf->mode_cfg) {
931                        switch (iph1->approval->authmethod) {
932#ifdef ENABLE_HYBRID
933                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_PSKEY_R:
934                        case OAKLEY_ATTR_AUTH_METHOD_HYBRID_RSA_R:
935                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSASIG_R:
936                        /* Unimplemeted... */
937                        case OAKLEY_ATTR_AUTH_METHOD_HYBRID_DSS_R:
938                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_DSSSIG_R:
939                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAENC_R:
940                        case OAKLEY_ATTR_AUTH_METHOD_XAUTH_RSAREV_R:
941                                break;
942#endif
943                        default:
944                                script_hook(iph1, SCRIPT_PHASE1_UP);
945                                break;
946                        }
947                }
948        }
949
950        return 0;
951}
952
953/*
954 * main function of quick mode.
955 */
956static int
957quick_main(iph2, msg)
958        struct ph2handle *iph2;
959        vchar_t *msg;
960{
961        struct isakmp *isakmp = (struct isakmp *)msg->v;
962        int error;
963#ifdef ENABLE_STATS
964        struct timeval start, end;
965#endif
966
967        /* ignore a packet */
968        if (iph2->status == PHASE2ST_ESTABLISHED
969         || iph2->status == PHASE2ST_GETSPISENT)
970                return 0;
971
972#ifdef ENABLE_STATS
973        gettimeofday(&start, NULL);
974#endif
975
976        /* receive */
977        if (ph2exchange[etypesw2(isakmp->etype)]
978                       [iph2->side]
979                       [iph2->status] == NULL) {
980                plog(LLV_ERROR, LOCATION, iph2->ph1->remote,
981                        "why isn't the function defined.\n");
982                return -1;
983        }
984        error = (ph2exchange[etypesw2(isakmp->etype)]
985                            [iph2->side]
986                            [iph2->status])(iph2, msg);
987        if (error != 0) {
988                plog(LLV_ERROR, LOCATION, iph2->ph1->remote,
989                        "failed to pre-process ph2 packet (side: %d, status %d).\n",
990                        iph2->side, iph2->status);
991                if (error == ISAKMP_INTERNAL_ERROR)
992                        return 0;
993                isakmp_info_send_n1(iph2->ph1, error, NULL);
994                return -1;
995        }
996
997        /* when using commit bit, status will be reached here. */
998        if (iph2->status == PHASE2ST_ADDSA)
999                return 0;
1000
1001        /* free resend buffer */
1002        if (iph2->sendbuf == NULL) {
1003                plog(LLV_ERROR, LOCATION, NULL,
1004                        "no buffer found as sendbuf\n");
1005                return -1;
1006        }
1007        VPTRINIT(iph2->sendbuf);
1008
1009        /* turn off schedule */
1010        sched_cancel(&iph2->scr);
1011
1012        /* send */
1013        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
1014        if ((ph2exchange[etypesw2(isakmp->etype)]
1015                        [iph2->side]
1016                        [iph2->status])(iph2, msg) != 0) {
1017                plog(LLV_ERROR, LOCATION, iph2->ph1->remote,
1018                        "failed to process ph2 packet (side: %d, status: %d).\n",
1019                        iph2->side, iph2->status);
1020                return -1;
1021        }
1022
1023#ifdef ENABLE_STATS
1024        gettimeofday(&end, NULL);
1025        syslog(LOG_NOTICE, "%s(%s): %8.6f",
1026                "phase2",
1027                s_isakmp_state(ISAKMP_ETYPE_QUICK, iph2->side, iph2->status),
1028                timedelta(&start, &end));
1029#endif
1030
1031        return 0;
1032}
1033
1034/* new negotiation of phase 1 for initiator */
1035struct ph1handle *
1036isakmp_ph1begin_i(rmconf, remote, local)
1037        struct remoteconf *rmconf;
1038        struct sockaddr *remote, *local;
1039{
1040        struct ph1handle *iph1;
1041#ifdef ENABLE_STATS
1042        struct timeval start, end;
1043#endif
1044
1045        /* get new entry to isakmp status table. */
1046        iph1 = newph1();
1047        if (iph1 == NULL)
1048                return NULL;
1049
1050        iph1->status = PHASE1ST_START;
1051        iph1->rmconf = rmconf;
1052        iph1->side = INITIATOR;
1053        iph1->version = ISAKMP_VERSION_NUMBER;
1054        iph1->msgid = 0;
1055        iph1->flags = 0;
1056        iph1->ph2cnt = 0;
1057#ifdef HAVE_GSSAPI
1058        iph1->gssapi_state = NULL;
1059#endif
1060#ifdef ENABLE_HYBRID
1061        if ((iph1->mode_cfg = isakmp_cfg_mkstate()) == NULL) {
1062                delph1(iph1);
1063                return NULL;
1064        }
1065#endif
1066#ifdef ENABLE_FRAG
1067
1068        if(rmconf->ike_frag == ISAKMP_FRAG_FORCE)
1069                iph1->frag = 1;
1070        else
1071                iph1->frag = 0;
1072        iph1->frag_last_index = 0;
1073        iph1->frag_chain = NULL;
1074#endif
1075        iph1->approval = NULL;
1076
1077        /* XXX copy remote address */
1078        if (copy_ph1addresses(iph1, rmconf, remote, local) < 0) {
1079                delph1(iph1);
1080                return NULL;
1081        }
1082
1083        (void)insph1(iph1);
1084
1085        /* start phase 1 exchange */
1086        iph1->etype = rmconf->etypes->type;
1087
1088        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
1089    {
1090        char *a;
1091
1092        a = racoon_strdup(saddr2str(iph1->local));
1093        STRDUP_FATAL(a);
1094
1095        plog(LLV_INFO, LOCATION, NULL,
1096                "initiate new phase 1 negotiation: %s<=>%s\n",
1097                a, saddr2str(iph1->remote));
1098        racoon_free(a);
1099    }
1100        plog(LLV_INFO, LOCATION, NULL,
1101                "begin %s mode.\n",
1102                s_isakmp_etype(iph1->etype));
1103
1104#ifdef ENABLE_STATS
1105        gettimeofday(&iph1->start, NULL);
1106        gettimeofday(&start, NULL);
1107#endif
1108        /* start exchange */
1109        if ((ph1exchange[etypesw1(iph1->etype)]
1110                        [iph1->side]
1111                        [iph1->status])(iph1, NULL) != 0) {
1112                /* failed to start phase 1 negotiation */
1113                remph1(iph1);
1114                delph1(iph1);
1115
1116                return NULL;
1117        }
1118
1119#ifdef ENABLE_STATS
1120        gettimeofday(&end, NULL);
1121        syslog(LOG_NOTICE, "%s(%s): %8.6f",
1122                "phase1",
1123                s_isakmp_state(iph1->etype, iph1->side, iph1->status),
1124                timedelta(&start, &end));
1125#endif
1126
1127        return iph1;
1128}
1129
1130/* new negotiation of phase 1 for responder */
1131static int
1132isakmp_ph1begin_r(msg, remote, local, etype)
1133        vchar_t *msg;
1134        struct sockaddr *remote, *local;
1135        u_int8_t etype;
1136{
1137        struct isakmp *isakmp = (struct isakmp *)msg->v;
1138        struct ph1handle *iph1;
1139        struct rmconfselector rmsel;
1140#ifdef ENABLE_STATS
1141        struct timeval start, end;
1142#endif
1143
1144        /* check if this etype is allowed */
1145        memset(&rmsel, 0, sizeof(rmsel));
1146        rmsel.remote = remote;
1147        if (enumrmconf(&rmsel, check_etypeok, (void *) (intptr_t) etype) == 0) {
1148                plog(LLV_ERROR, LOCATION, remote,
1149                     "exchange %s not allowed in any applicable rmconf.\n",
1150                     s_isakmp_etype(etype));
1151                return -1;
1152        }
1153
1154        /* get new entry to isakmp status table. */
1155        iph1 = newph1();
1156        if (iph1 == NULL)
1157                return -1;
1158
1159        memcpy(&iph1->index.i_ck, &isakmp->i_ck, sizeof(iph1->index.i_ck));
1160        iph1->status = PHASE1ST_START;
1161        iph1->flags = 0;
1162        iph1->side = RESPONDER;
1163        iph1->etype = etype;
1164        iph1->version = isakmp->v;
1165        iph1->msgid = 0;
1166#ifdef HAVE_GSSAPI
1167        iph1->gssapi_state = NULL;
1168#endif
1169#ifdef ENABLE_HYBRID
1170        if ((iph1->mode_cfg = isakmp_cfg_mkstate()) == NULL) {
1171                delph1(iph1);
1172                return -1;
1173        }
1174#endif
1175#ifdef ENABLE_FRAG
1176        iph1->frag = 0;
1177        iph1->frag_last_index = 0;
1178        iph1->frag_chain = NULL;
1179#endif
1180        iph1->approval = NULL;
1181
1182#ifdef ENABLE_NATT
1183        /* RFC3947 says that we MUST accept new phases1 on NAT-T floated port.
1184         * We have to setup this flag now to correctly generate the first reply.
1185         * Don't know if a better check could be done for that ?
1186         */
1187        if(extract_port(local) == lcconf->port_isakmp_natt)
1188                iph1->natt_flags |= (NAT_PORTS_CHANGED);
1189#endif
1190
1191        /* copy remote address; remote and local always contain
1192         * port numbers so rmconf is not needed */
1193        if (copy_ph1addresses(iph1, NULL, remote, local) < 0) {
1194                delph1(iph1);
1195                return -1;
1196        }
1197        (void)insph1(iph1);
1198
1199        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
1200    {
1201        char *a;
1202
1203        a = racoon_strdup(saddr2str(iph1->local));
1204        STRDUP_FATAL(a);
1205
1206        plog(LLV_INFO, LOCATION, NULL,
1207                "respond new phase 1 negotiation: %s<=>%s\n",
1208                a, saddr2str(iph1->remote));
1209        racoon_free(a);
1210    }
1211        plog(LLV_INFO, LOCATION, NULL,
1212                "begin %s mode.\n", s_isakmp_etype(etype));
1213
1214#ifdef ENABLE_STATS
1215        gettimeofday(&iph1->start, NULL);
1216        gettimeofday(&start, NULL);
1217#endif
1218
1219#ifndef ENABLE_FRAG
1220
1221        /* start exchange */
1222        if ((ph1exchange[etypesw1(iph1->etype)]
1223                        [iph1->side]
1224                        [iph1->status])(iph1, msg) < 0
1225         || (ph1exchange[etypesw1(iph1->etype)]
1226                        [iph1->side]
1227                        [iph1->status])(iph1, msg) < 0) {
1228                plog(LLV_ERROR, LOCATION, remote,
1229                        "failed to process ph1 packet (side: %d, status: %d).\n",
1230                        iph1->side, iph1->status);
1231                remph1(iph1);
1232                delph1(iph1);
1233                return -1;
1234        }
1235
1236#ifdef ENABLE_STATS
1237        gettimeofday(&end, NULL);
1238        syslog(LOG_NOTICE, "%s(%s): %8.6f",
1239                "phase1",
1240                s_isakmp_state(iph1->etype, iph1->side, iph1->status),
1241                timedelta(&start, &end));
1242#endif
1243
1244        return 0;
1245
1246#else /* ENABLE_FRAG */
1247
1248        /* now that we have a phase1 handle, feed back into our
1249         * main receive function to catch fragmented packets
1250         */
1251
1252        return isakmp_main(msg, remote, local);
1253
1254#endif /* ENABLE_FRAG */
1255
1256}
1257
1258/* new negotiation of phase 2 for initiator */
1259static int
1260isakmp_ph2begin_i(iph1, iph2)
1261        struct ph1handle *iph1;
1262        struct ph2handle *iph2;
1263{
1264#ifdef ENABLE_HYBRID
1265        if (xauth_check(iph1) != 0) {
1266                plog(LLV_ERROR, LOCATION, NULL,
1267                    "Attempt to start phase 2 whereas Xauth failed\n");
1268                return -1;
1269        }
1270#endif
1271
1272        /* fixup ph2 ports for this ph1 */
1273        if (extract_port(iph2->src) == 0)
1274                set_port(iph2->src, extract_port(iph1->local));
1275        if (extract_port(iph2->dst) == 0)
1276                set_port(iph2->dst, extract_port(iph1->remote));
1277
1278        /* found ISAKMP-SA. */
1279        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
1280        plog(LLV_DEBUG, LOCATION, NULL, "begin QUICK mode.\n");
1281    {
1282        char *a;
1283        a = racoon_strdup(saddr2str(iph2->src));
1284        STRDUP_FATAL(a);
1285
1286        plog(LLV_INFO, LOCATION, NULL,
1287                "initiate new phase 2 negotiation: %s<=>%s\n",
1288                a, saddr2str(iph2->dst));
1289        racoon_free(a);
1290    }
1291
1292#ifdef ENABLE_STATS
1293        gettimeofday(&iph2->start, NULL);
1294#endif
1295        if (iph2->status != PHASE2ST_EXPIRED) /* Phase 1 is already bound (ongoing rekeying) */
1296                bindph12(iph1, iph2);
1297        iph2->status = PHASE2ST_STATUS2;
1298
1299        if ((ph2exchange[etypesw2(ISAKMP_ETYPE_QUICK)]
1300                         [iph2->side]
1301                         [iph2->status])(iph2, NULL) < 0) {
1302                /* release ipsecsa handler due to internal error. */
1303                remph2(iph2);
1304                return -1;
1305        }
1306        return 0;
1307}
1308
1309/* new negotiation of phase 2 for responder */
1310static int
1311isakmp_ph2begin_r(iph1, msg)
1312        struct ph1handle *iph1;
1313        vchar_t *msg;
1314{
1315        struct isakmp *isakmp = (struct isakmp *)msg->v;
1316        struct ph2handle *iph2 = 0;
1317        int error;
1318#ifdef ENABLE_STATS
1319        struct timeval start, end;
1320#endif
1321#ifdef ENABLE_HYBRID
1322        if (xauth_check(iph1) != 0) {
1323                plog(LLV_ERROR, LOCATION, NULL,
1324                    "Attempt to start phase 2 whereas Xauth failed\n");
1325                return -1;
1326        }
1327#endif
1328
1329        iph2 = newph2();
1330        if (iph2 == NULL) {
1331                plog(LLV_ERROR, LOCATION, NULL,
1332                        "failed to allocate phase2 entry.\n");
1333                return -1;
1334        }
1335
1336        iph2->side = RESPONDER;
1337        iph2->status = PHASE2ST_START;
1338        iph2->flags = isakmp->flags;
1339        iph2->msgid = isakmp->msgid;
1340        iph2->seq = pk_getseq();
1341        iph2->ivm = oakley_newiv2(iph1, iph2->msgid);
1342        if (iph2->ivm == NULL) {
1343                delph2(iph2);
1344                return -1;
1345        }
1346        iph2->dst = dupsaddr(iph1->remote);     /* XXX should be considered */
1347        if (iph2->dst == NULL) {
1348                delph2(iph2);
1349                return -1;
1350        }
1351        iph2->src = dupsaddr(iph1->local);      /* XXX should be considered */
1352        if (iph2->src == NULL) {
1353                delph2(iph2);
1354                return -1;
1355        }
1356
1357        /* add new entry to isakmp status table */
1358        insph2(iph2);
1359        bindph12(iph1, iph2);
1360
1361        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
1362    {
1363        char *a;
1364
1365        a = racoon_strdup(saddr2str(iph2->src));
1366        STRDUP_FATAL(a);
1367
1368        plog(LLV_INFO, LOCATION, NULL,
1369                "respond new phase 2 negotiation: %s<=>%s\n",
1370                a, saddr2str(iph2->dst));
1371        racoon_free(a);
1372    }
1373
1374#ifdef ENABLE_STATS
1375        gettimeofday(&start, NULL);
1376#endif
1377
1378        error = (ph2exchange[etypesw2(ISAKMP_ETYPE_QUICK)]
1379                           [iph2->side]
1380                           [iph2->status])(iph2, msg);
1381        if (error != 0) {
1382                plog(LLV_ERROR, LOCATION, iph1->remote,
1383                        "failed to pre-process ph2 packet (side: %d, status: %d).\n",
1384                        iph2->side, iph2->status);
1385                if (error != ISAKMP_INTERNAL_ERROR)
1386                        isakmp_info_send_n1(iph2->ph1, error, NULL);
1387                /*
1388                 * release handler because it's wrong that ph2handle is kept
1389                 * after failed to check message for responder's.
1390                 */
1391                remph2(iph2);
1392                delph2(iph2);
1393                return -1;
1394        }
1395
1396        /* send */
1397        plog(LLV_DEBUG, LOCATION, NULL, "===\n");
1398        if ((ph2exchange[etypesw2(isakmp->etype)]
1399                        [iph2->side]
1400                        [iph2->status])(iph2, msg) < 0) {
1401                plog(LLV_ERROR, LOCATION, iph2->ph1->remote,
1402                        "failed to process ph2 packet (side: %d, status: %d).\n",
1403                        iph2->side, iph2->status);
1404                /* don't release handler */
1405                return -1;
1406        }
1407#ifdef ENABLE_STATS
1408        gettimeofday(&end, NULL);
1409        syslog(LOG_NOTICE, "%s(%s): %8.6f",
1410                "phase2",
1411                s_isakmp_state(ISAKMP_ETYPE_QUICK, iph2->side, iph2->status),
1412                timedelta(&start, &end));
1413#endif
1414
1415        return 0;
1416}
1417
1418/*
1419 * parse ISAKMP payloads, without ISAKMP base header.
1420 */
1421vchar_t *
1422isakmp_parsewoh(np0, gen, len)
1423        int np0;
1424        struct isakmp_gen *gen;
1425        int len;
1426{
1427        u_char np = np0 & 0xff;
1428        int tlen, plen;
1429        vchar_t *result;
1430        struct isakmp_parse_t *p, *ep;
1431
1432        plog(LLV_DEBUG, LOCATION, NULL, "begin.\n");
1433
1434        /*
1435         * 5 is a magic number, but any value larger than 2 should be fine
1436         * as we do vrealloc() in the following loop.
1437         */
1438        result = vmalloc(sizeof(struct isakmp_parse_t) * 5);
1439        if (result == NULL) {
1440                plog(LLV_ERROR, LOCATION, NULL,
1441                        "failed to get buffer.\n");
1442                return NULL;
1443        }
1444        p = (struct isakmp_parse_t *)result->v;
1445        ep = (struct isakmp_parse_t *)(result->v + result->l - sizeof(*ep));
1446
1447        tlen = len;
1448
1449        /* parse through general headers */
1450        while (0 < tlen && np != ISAKMP_NPTYPE_NONE) {
1451                if (tlen <= sizeof(struct isakmp_gen)) {
1452                        /* don't send information, see isakmp_ident_r1() */
1453                        plog(LLV_ERROR, LOCATION, NULL,
1454                                "invalid length of payload\n");
1455                        vfree(result);
1456                        return NULL;
1457                }
1458
1459                plog(LLV_DEBUG, LOCATION, NULL,
1460                        "seen nptype=%u(%s)\n", np, s_isakmp_nptype(np));
1461
1462                p->type = np;
1463                p->len = ntohs(gen->len);
1464                if (p->len < sizeof(struct isakmp_gen) || p->len > tlen) {
1465                        plog(LLV_DEBUG, LOCATION, NULL,
1466                                "invalid length of payload\n");
1467                        vfree(result);
1468                        return NULL;
1469                }
1470                p->ptr = gen;
1471                p++;
1472                if (ep <= p) {
1473                        int off;
1474
1475                        off = p - (struct isakmp_parse_t *)result->v;
1476                        result = vrealloc(result, result->l * 2);
1477                        if (result == NULL) {
1478                                plog(LLV_DEBUG, LOCATION, NULL,
1479                                        "failed to realloc buffer.\n");
1480                                vfree(result);
1481                                return NULL;
1482                        }
1483                        ep = (struct isakmp_parse_t *)
1484                                (result->v + result->l - sizeof(*ep));
1485                        p = (struct isakmp_parse_t *)result->v;
1486                        p += off;
1487                }
1488
1489                np = gen->np;
1490                plen = ntohs(gen->len);
1491                gen = (struct isakmp_gen *)((caddr_t)gen + plen);
1492                tlen -= plen;
1493        }
1494        p->type = ISAKMP_NPTYPE_NONE;
1495        p->len = 0;
1496        p->ptr = NULL;
1497
1498        plog(LLV_DEBUG, LOCATION, NULL, "succeed.\n");
1499
1500        return result;
1501}
1502
1503/*
1504 * parse ISAKMP payloads, including ISAKMP base header.
1505 */
1506vchar_t *
1507isakmp_parse(buf)
1508        vchar_t *buf;
1509{
1510        struct isakmp *isakmp = (struct isakmp *)buf->v;
1511        struct isakmp_gen *gen;
1512        int tlen;
1513        vchar_t *result;
1514        u_char np;
1515
1516        np = isakmp->np;
1517        gen = (struct isakmp_gen *)(buf->v + sizeof(*isakmp));
1518        tlen = buf->l - sizeof(struct isakmp);
1519        result = isakmp_parsewoh(np, gen, tlen);
1520
1521        return result;
1522}
1523
1524/* %%% */
1525int
1526isakmp_init()
1527{
1528        /* initialize a isakmp status table */
1529        initph1tree();
1530        initph2tree();
1531        initctdtree();
1532        init_recvdpkt();
1533
1534        return 0;
1535}
1536
1537/*
1538 * make strings containing i_cookie + r_cookie + msgid
1539 */
1540const char *
1541isakmp_pindex(index, msgid)
1542        const isakmp_index *index;
1543        const u_int32_t msgid;
1544{
1545        static char buf[64];
1546        const u_char *p;
1547        int i, j;
1548
1549        memset(buf, 0, sizeof(buf));
1550
1551        /* copy index */
1552        p = (const u_char *)index;
1553        for (j = 0, i = 0; i < sizeof(isakmp_index); i++) {
1554                snprintf((char *)&buf[j], sizeof(buf) - j, "%02x", p[i]);
1555                j += 2;
1556                switch (i) {
1557                case 7:
1558                        buf[j++] = ':';
1559                }
1560        }
1561
1562        if (msgid == 0)
1563                return buf;
1564
1565        /* copy msgid */
1566        snprintf((char *)&buf[j], sizeof(buf) - j, ":%08x", ntohs(msgid));
1567
1568        return buf;
1569}
1570
1571/* open ISAKMP sockets. */
1572int
1573isakmp_open(struct sockaddr *addr, int udp_encap)
1574{
1575        const int yes = 1;
1576        int ifnum = 0, encap_ifnum = 0, fd;
1577        struct sockaddr_in *sin = (struct sockaddr_in *) addr;
1578#ifdef INET6
1579        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) addr;
1580        int pktinfo;
1581#endif
1582#ifdef ENABLE_NATT
1583        int option = -1;
1584#endif
1585
1586        /* warn if wildcard address - should we forbid this? */
1587        switch (addr->sa_family) {
1588        case AF_INET:
1589                if (sin->sin_addr.s_addr == 0)
1590                        plog(LLV_WARNING, LOCATION, NULL,
1591                             "listening to wildcard address,"
1592                             "broadcast IKE packet may kill you\n");
1593                break;
1594#ifdef INET6
1595        case AF_INET6:
1596                if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) {
1597                        plog(LLV_DEBUG, LOCATION, NULL,
1598                             "ignoring multicast address %s\n",
1599                             saddr2str(addr));
1600                        return -1;
1601                }
1602
1603                if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
1604                        plog(LLV_WARNING, LOCATION, NULL,
1605                             "listening to wildcard address, "
1606                             "broadcast IKE packet may kill you\n");
1607                break;
1608#endif
1609        default:
1610                plog(LLV_ERROR, LOCATION, NULL,
1611                     "unsupported address family %d\n",
1612                     addr->sa_family);
1613                return -1;
1614        }
1615
1616        if ((fd = privsep_socket(addr->sa_family, SOCK_DGRAM, 0)) < 0) {
1617                plog(LLV_ERROR, LOCATION, NULL,
1618                     "socket(%s)\n", strerror(errno));
1619                return -1;
1620        }
1621        close_on_exec(fd);
1622        if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1)
1623                plog(LLV_WARNING, LOCATION, NULL,
1624                     "failed to put socket in non-blocking mode\n");
1625
1626        /* receive my interface address on inbound packets. */
1627        switch (addr->sa_family) {
1628        case AF_INET:
1629                if (setsockopt(fd, IPPROTO_IP,
1630#ifdef __linux__
1631                               IP_PKTINFO,
1632#else
1633                               IP_RECVDSTADDR,
1634#endif
1635                               (const void *) &yes, sizeof(yes)) < 0) {
1636                        plog(LLV_ERROR, LOCATION, NULL,
1637                             "setsockopt IP_RECVDSTADDR (%s)\n",
1638                             strerror(errno));
1639                        goto err;
1640                }
1641
1642#ifdef ENABLE_NATT
1643                if (udp_encap)
1644                        option = UDP_ENCAP_ESPINUDP;
1645#if defined(ENABLE_NATT_00) || defined(ENABLE_NATT_01)
1646                else
1647                        option = UDP_ENCAP_ESPINUDP_NON_IKE;
1648#endif
1649                if (option == -1)
1650                        break;
1651
1652                if (setsockopt(fd, SOL_UDP,
1653                               UDP_ENCAP, &option,
1654                               sizeof(option)) < 0) {
1655                        plog(LLV_WARNING, LOCATION, NULL,
1656                             "setsockopt(%s): UDP_ENCAP %s\n",
1657                             option == UDP_ENCAP_ESPINUDP ? "UDP_ENCAP_ESPINUDP" : "UDP_ENCAP_ESPINUDP_NON_IKE",
1658                             strerror(errno));
1659                } else {
1660                        plog(LLV_INFO, LOCATION, NULL,
1661                             "%s used for NAT-T\n",
1662                             saddr2str(addr));
1663                }
1664#endif
1665                break;
1666
1667#ifdef INET6
1668        case AF_INET6:
1669#if defined(INET6_ADVAPI)
1670#ifdef IPV6_RECVPKTINFO
1671                pktinfo = IPV6_RECVPKTINFO;
1672#else  /* old adv. API */
1673                pktinfo = IPV6_PKTINFO;
1674#endif /* IPV6_RECVPKTINFO */
1675#else
1676                pktinfo = IPV6_RECVDSTADDR;
1677#endif
1678                if (setsockopt(fd, IPPROTO_IPV6, pktinfo,
1679                               (const void *) &yes, sizeof(yes)) < 0) {
1680                        plog(LLV_ERROR, LOCATION, NULL,
1681                             "setsockopt IPV6_RECVDSTADDR (%d):%s\n",
1682                             pktinfo, strerror(errno));
1683                        goto err;
1684                }
1685
1686#ifdef IPV6_USE_MIN_MTU
1687                if (setsockopt(fd, IPPROTO_IPV6, IPV6_USE_MIN_MTU,
1688                               (void *) &yes, sizeof(yes)) < 0) {
1689                        plog(LLV_ERROR, LOCATION, NULL,
1690                             "setsockopt IPV6_USE_MIN_MTU (%s)\n",
1691                             strerror(errno));
1692                        goto err;
1693                }
1694#endif
1695                break;
1696#endif
1697        }
1698
1699        if (setsockopt(fd, SOL_SOCKET,
1700#ifdef __linux__
1701                       SO_REUSEADDR,
1702#else
1703                       SO_REUSEPORT,
1704#endif
1705                       (void *) &yes, sizeof(yes)) < 0) {
1706                plog(LLV_ERROR, LOCATION, NULL,
1707                     "failed to set REUSE flag on %s (%s).\n",
1708                     saddr2str(addr), strerror(errno));
1709                goto err;
1710        }
1711
1712        if (setsockopt_bypass(fd, addr->sa_family) < 0)
1713                goto err;
1714
1715        if (privsep_bind(fd, addr, sysdep_sa_len(addr)) < 0) {
1716                plog(LLV_ERROR, LOCATION, addr,
1717                     "failed to bind to address %s (%s).\n",
1718                     saddr2str(addr), strerror(errno));
1719                goto err;
1720        }
1721
1722        plog(LLV_INFO, LOCATION, NULL,
1723             "%s used as isakmp port (fd=%d)\n",
1724             saddr2str(addr), fd);
1725
1726        monitor_fd(fd, isakmp_handler, NULL, 1);
1727        return fd;
1728
1729err:
1730        close(fd);
1731        return -1;
1732}
1733
1734void
1735isakmp_close(int fd)
1736{
1737        unmonitor_fd(fd);
1738        close(fd);
1739}
1740
1741int
1742isakmp_send(iph1, sbuf)
1743        struct ph1handle *iph1;
1744        vchar_t *sbuf;
1745{
1746        int len = 0;
1747        int s;
1748        vchar_t *vbuf = NULL, swap;
1749
1750#ifdef ENABLE_NATT
1751        size_t extralen = NON_ESP_MARKER_USE(iph1) ? NON_ESP_MARKER_LEN : 0;
1752
1753        /* Check if NON_ESP_MARKER_LEN is already there (happens when resending packets)
1754         */
1755        if(extralen == NON_ESP_MARKER_LEN &&
1756           *(u_int32_t *)sbuf->v == 0)
1757                extralen = 0;
1758
1759#ifdef ENABLE_FRAG
1760        /*
1761         * Do not add the non ESP marker for a packet that will
1762         * be fragmented. The non ESP marker should appear in
1763         * all fragment's packets, but not in the fragmented packet
1764         */
1765        if (iph1->frag && sbuf->l > ISAKMP_FRAG_MAXLEN)
1766                extralen = 0;
1767#endif
1768        if (extralen)
1769                plog (LLV_DEBUG, LOCATION, NULL, "Adding NON-ESP marker\n");
1770
1771        /* If NAT-T port floating is in use, 4 zero bytes (non-ESP marker)
1772           must added just before the packet itself. For this we must
1773           allocate a new buffer and release it at the end. */
1774        if (extralen) {
1775                if ((vbuf = vmalloc (sbuf->l + extralen)) == NULL) {
1776                        plog(LLV_ERROR, LOCATION, NULL,
1777                            "vbuf allocation failed\n");
1778                        return -1;
1779                }
1780                *(u_int32_t *)vbuf->v = 0;
1781                memcpy (vbuf->v + extralen, sbuf->v, sbuf->l);
1782                /* ensures that the modified buffer will be sent back to the caller, so
1783                 * add_recvdpkt() will add the correct buffer
1784                 */
1785                swap = *sbuf;
1786                *sbuf = *vbuf;
1787                *vbuf = swap;
1788                vfree(vbuf);
1789        }
1790#endif
1791
1792        /* select the socket to be sent */
1793        s = myaddr_getfd(iph1->local);
1794        if (s == -1)
1795                return -1;
1796
1797        plog (LLV_DEBUG, LOCATION, NULL, "%zu bytes %s\n", sbuf->l,
1798              saddr2str_fromto("from %s to %s", iph1->local, iph1->remote));
1799
1800#ifdef ENABLE_FRAG
1801        if (iph1->frag && sbuf->l > ISAKMP_FRAG_MAXLEN) {
1802                if (isakmp_sendfrags(iph1, sbuf) == -1) {
1803                        plog(LLV_ERROR, LOCATION, NULL,
1804                            "isakmp_sendfrags failed\n");
1805                        return -1;
1806                }
1807        } else
1808#endif
1809        {
1810                len = sendfromto(s, sbuf->v, sbuf->l,
1811                    iph1->local, iph1->remote, lcconf->count_persend);
1812
1813                if (len == -1) {
1814                        plog(LLV_ERROR, LOCATION, NULL, "sendfromto failed\n");
1815                        return -1;
1816                }
1817        }
1818
1819        return 0;
1820}
1821
1822/* called from scheduler */
1823static void
1824isakmp_ph1resend_stub(p)
1825        struct sched *p;
1826{
1827        struct ph1handle *iph1 = container_of(p, struct ph1handle, scr);
1828
1829        if (isakmp_ph1resend(iph1) < 0) {
1830                remph1(iph1);
1831                delph1(iph1);
1832        }
1833}
1834
1835static int
1836isakmp_ph1resend(iph1)
1837        struct ph1handle *iph1;
1838{
1839        /* Note: NEVER do the rem/del here, it will be done by the caller or by the _stub function
1840         */
1841        if (iph1->retry_counter <= 0) {
1842                plog(LLV_ERROR, LOCATION, NULL,
1843                        "phase1 negotiation failed due to time up. %s\n",
1844                        isakmp_pindex(&iph1->index, iph1->msgid));
1845                /* XXX is the peer really "dead" here ??? */
1846                script_hook(iph1, SCRIPT_PHASE1_DEAD);
1847                evt_phase1(iph1, EVT_PHASE1_NO_RESPONSE, NULL);
1848
1849                return -1;
1850        }
1851
1852        if (isakmp_send(iph1, iph1->sendbuf) < 0){
1853                plog(LLV_ERROR, LOCATION, NULL,
1854                         "phase1 negotiation failed due to send error. %s\n",
1855                         isakmp_pindex(&iph1->index, iph1->msgid));
1856                evt_phase1(iph1, EVT_PHASE1_NO_RESPONSE, NULL);
1857                return -1;
1858        }
1859
1860        plog(LLV_DEBUG, LOCATION, NULL,
1861                "resend phase1 packet %s\n",
1862                isakmp_pindex(&iph1->index, iph1->msgid));
1863
1864        iph1->retry_counter--;
1865
1866        sched_schedule(&iph1->scr, lcconf->retry_interval,
1867                       isakmp_ph1resend_stub);
1868
1869        return 0;
1870}
1871
1872int
1873isakmp_ph1send(iph1)
1874        struct ph1handle *iph1;
1875{
1876        iph1->retry_counter = lcconf->retry_counter;
1877        return isakmp_ph1resend(iph1);
1878}
1879
1880/* called from scheduler */
1881static void
1882isakmp_ph2resend_stub(p)
1883        struct sched *p;
1884{
1885        struct ph2handle *iph2 = container_of(p, struct ph2handle, scr);
1886
1887        if (isakmp_ph2resend(iph2) < 0) {
1888                remph2(iph2);
1889                delph2(iph2);
1890        }
1891}
1892
1893static int
1894isakmp_ph2resend(iph2)
1895        struct ph2handle *iph2;
1896{
1897        /* Note: NEVER do the unbind/rem/del here, it will be done by the caller or by the _stub function
1898         */
1899        if (iph2->ph1->status >= PHASE1ST_EXPIRED) {
1900                plog(LLV_ERROR, LOCATION, NULL,
1901                        "phase2 negotiation failed due to phase1 expired. %s\n",
1902                                isakmp_pindex(&iph2->ph1->index, iph2->msgid));
1903                return -1;
1904        }
1905
1906        if (iph2->retry_counter <= 0) {
1907                plog(LLV_ERROR, LOCATION, NULL,
1908                        "phase2 negotiation failed due to time up. %s\n",
1909                                isakmp_pindex(&iph2->ph1->index, iph2->msgid));
1910                evt_phase2(iph2, EVT_PHASE2_NO_RESPONSE, NULL);
1911                unbindph12(iph2);
1912                return -1;
1913        }
1914
1915        if (isakmp_send(iph2->ph1, iph2->sendbuf) < 0){
1916                plog(LLV_ERROR, LOCATION, NULL,
1917                        "phase2 negotiation failed due to send error. %s\n",
1918                                isakmp_pindex(&iph2->ph1->index, iph2->msgid));
1919                evt_phase2(iph2, EVT_PHASE2_NO_RESPONSE, NULL);
1920                return -1;
1921        }
1922
1923        plog(LLV_DEBUG, LOCATION, NULL,
1924                "resend phase2 packet %s\n",
1925                isakmp_pindex(&iph2->ph1->index, iph2->msgid));
1926
1927        iph2->retry_counter--;
1928
1929        sched_schedule(&iph2->scr, lcconf->retry_interval,
1930                       isakmp_ph2resend_stub);
1931
1932        return 0;
1933}
1934
1935int
1936isakmp_ph2send(iph2)
1937        struct ph2handle *iph2;
1938{
1939        iph2->retry_counter = lcconf->retry_counter;
1940        return isakmp_ph2resend(iph2);
1941}
1942
1943/* called from scheduler */
1944void
1945isakmp_ph1dying_stub(p)
1946        struct sched *p;
1947{
1948
1949        isakmp_ph1dying(container_of(p, struct ph1handle, sce));
1950}
1951
1952void
1953isakmp_ph1dying(iph1)
1954        struct ph1handle *iph1;
1955{
1956        struct ph1handle *new_iph1;
1957        struct ph2handle *p;
1958        struct remoteconf *rmconf;
1959
1960        if (iph1->status >= PHASE1ST_DYING)
1961                return;
1962
1963        /* Going away in after a while... */
1964        iph1->status = PHASE1ST_DYING;
1965
1966        /* Any fresh phase1s? */
1967        new_iph1 = getph1(iph1, iph1->local, iph1->remote, 1);
1968        if (new_iph1 == NULL) {
1969                LIST_FOREACH(p, &iph1->ph2tree, ph1bind) {
1970                        if (p->status != PHASE2ST_ESTABLISHED)
1971                                continue;
1972
1973                        plog(LLV_INFO, LOCATION, NULL,
1974                             "renegotiating phase1 to %s due to "
1975                             "active phase2\n",
1976                             saddrwop2str(iph1->remote));
1977
1978                        if (iph1->side == INITIATOR)
1979                                isakmp_ph1begin_i(iph1->rmconf, iph1->remote,
1980                                                  iph1->local);
1981
1982                        break;
1983                }
1984        } else {
1985                migrate_ph12(iph1, new_iph1);
1986        }
1987
1988        /* Schedule for expiration */
1989        sched_schedule(&iph1->sce, iph1->approval->lifetime *
1990                       (100 - PFKEY_SOFT_LIFETIME_RATE) / 100,
1991                       isakmp_ph1expire_stub);
1992}
1993
1994/* called from scheduler */
1995void
1996isakmp_ph1expire_stub(p)
1997        struct sched *p;
1998{
1999        isakmp_ph1expire(container_of(p, struct ph1handle, sce));
2000}
2001
2002void
2003isakmp_ph1expire(iph1)
2004        struct ph1handle *iph1;
2005{
2006        char *src, *dst;
2007
2008        if (iph1->status < PHASE1ST_EXPIRED) {
2009                src = racoon_strdup(saddr2str(iph1->local));
2010                dst = racoon_strdup(saddr2str(iph1->remote));
2011                STRDUP_FATAL(src);
2012                STRDUP_FATAL(dst);
2013
2014                plog(LLV_INFO, LOCATION, NULL,
2015                         "ISAKMP-SA expired %s-%s spi:%s\n",
2016                         src, dst,
2017                         isakmp_pindex(&iph1->index, 0));
2018                racoon_free(src);
2019                racoon_free(dst);
2020                iph1->status = PHASE1ST_EXPIRED;
2021        }
2022
2023        isakmp_ph1delete(iph1);
2024}
2025
2026/* called from scheduler */
2027void
2028isakmp_ph1delete_stub(p)
2029        struct sched *p;
2030{
2031
2032        isakmp_ph1delete(container_of(p, struct ph1handle, sce));
2033}
2034
2035void
2036isakmp_ph1delete(iph1)
2037        struct ph1handle *iph1;
2038{
2039        struct ph2handle *p, *next;
2040        struct ph1handle *new_iph1;
2041        char *src, *dst;
2042
2043        /* Migrate established phase2s. Any fresh phase1s? */
2044        new_iph1 = getph1(iph1, iph1->local, iph1->remote, 1);
2045        if (new_iph1 != NULL)
2046                migrate_ph12(iph1, new_iph1);
2047
2048        /* Discard any left phase2s */
2049        for (p = LIST_FIRST(&iph1->ph2tree); p; p = next) {
2050                next = LIST_NEXT(p, ph1bind);
2051                if (p->status == PHASE2ST_ESTABLISHED)
2052                        isakmp_info_send_d2(p);
2053                /* remove all ph2 handles,
2054                 * as ph1handle will be expired soon
2055                 */
2056                delete_spd(p, 1);
2057                remph2(p);
2058                delph2(p);
2059        }
2060
2061        src = racoon_strdup(saddr2str(iph1->local));
2062        dst = racoon_strdup(saddr2str(iph1->remote));
2063        STRDUP_FATAL(src);
2064        STRDUP_FATAL(dst);
2065
2066        plog(LLV_INFO, LOCATION, NULL,
2067                "ISAKMP-SA deleted %s-%s spi:%s\n",
2068                src, dst, isakmp_pindex(&iph1->index, 0));
2069
2070        evt_phase1(iph1, EVT_PHASE1_DOWN, NULL);
2071        if (new_iph1 == NULL && ph1_rekey_enabled(iph1))
2072                script_hook(iph1, SCRIPT_PHASE1_DEAD);
2073
2074        racoon_free(src);
2075        racoon_free(dst);
2076
2077        remph1(iph1);
2078        delph1(iph1);
2079}
2080
2081/* called from scheduler.
2082 * this function will call only isakmp_ph2delete().
2083 * phase 2 handler remain forever if kernel doesn't cry a expire of phase 2 SA
2084 * by something cause.  That's why this function is called after phase 2 SA
2085 * expires in the userland.
2086 */
2087void
2088isakmp_ph2expire_stub(p)
2089        struct sched *p;
2090{
2091
2092        isakmp_ph2expire(container_of(p, struct ph2handle, sce));
2093}
2094
2095void
2096isakmp_ph2expire(iph2)
2097        struct ph2handle *iph2;
2098{
2099        char *src, *dst;
2100
2101        src = racoon_strdup(saddrwop2str(iph2->src));
2102        dst = racoon_strdup(saddrwop2str(iph2->dst));
2103        STRDUP_FATAL(src);
2104        STRDUP_FATAL(dst);
2105
2106        plog(LLV_INFO, LOCATION, NULL,
2107                "phase2 sa expired %s-%s\n", src, dst);
2108        racoon_free(src);
2109        racoon_free(dst);
2110
2111        iph2->status = PHASE2ST_EXPIRED;
2112        sched_schedule(&iph2->sce, 1, isakmp_ph2delete_stub);
2113}
2114
2115/* called from scheduler */
2116void
2117isakmp_ph2delete_stub(p)
2118        struct sched *p;
2119{
2120
2121        isakmp_ph2delete(container_of(p, struct ph2handle, sce));
2122}
2123
2124void
2125isakmp_ph2delete(iph2)
2126        struct ph2handle *iph2;
2127{
2128        char *src, *dst;
2129
2130        src = racoon_strdup(saddrwop2str(iph2->src));
2131        dst = racoon_strdup(saddrwop2str(iph2->dst));
2132        STRDUP_FATAL(src);
2133        STRDUP_FATAL(dst);
2134
2135        plog(LLV_INFO, LOCATION, NULL,
2136                "phase2 sa deleted %s-%s\n", src, dst);
2137        racoon_free(src);
2138        racoon_free(dst);
2139
2140        remph2(iph2);
2141        delph2(iph2);
2142
2143        return;
2144}
2145
2146/* %%%
2147 * Interface between PF_KEYv2 and ISAKMP
2148 */
2149/*
2150 * receive ACQUIRE from kernel, and begin either phase1 or phase2.
2151 * if phase1 has been finished, begin phase2.
2152 */
2153int
2154isakmp_post_acquire(iph2, iph1hint, nopassive)
2155        struct ph2handle *iph2;
2156        struct ph1handle *iph1hint;
2157        int nopassive;
2158{
2159        struct remoteconf *rmconf;
2160        struct ph1handle *iph1 = NULL;
2161
2162        plog(LLV_DEBUG, LOCATION, NULL, "in post_acquire\n");
2163
2164        /* Search appropriate configuration with masking port. Note that
2165         * we always use iph2->dst, and not iph2->sa_dst.
2166         *
2167         * XXX One possible need for using iph2->sa_dst if not NULL would
2168         * be for selecting a remote configuration based on a stable
2169         * address of a mobile node (not a CoA provided by MIGRATE/KMADDRESS
2170         * as iph2->dst hint). This scenario would require additional changes,
2171         * so no need to bother yet. --arno */
2172
2173        if (iph1hint == NULL || iph1hint->rmconf == NULL) {
2174                rmconf = getrmconf(iph2->dst, nopassive ? GETRMCONF_F_NO_PASSIVE : 0);
2175                if (rmconf == NULL) {
2176                        plog(LLV_ERROR, LOCATION, NULL,
2177                                "no configuration found for %s.\n",
2178                                saddrwop2str(iph2->dst));
2179                        return -1;
2180                }
2181        } else {
2182                rmconf = iph1hint->rmconf;
2183        }
2184
2185        /* if passive mode, ignore the acquire message */
2186        if (nopassive && rmconf->passive) {
2187                plog(LLV_DEBUG, LOCATION, NULL,
2188                        "because of passive mode, "
2189                        "ignore the acquire message for %s.\n",
2190                        saddrwop2str(iph2->dst));
2191                return -1;
2192        }
2193
2194        /*
2195         * XXX Searching by IP addresses + ports might fail on
2196         * some cases, we should use the ISAKMP identity to search
2197         * matching ISAKMP.
2198         */
2199        iph1 = getph1(iph1hint, iph2->src, iph2->dst, 0);
2200
2201        /* no ISAKMP-SA found. */
2202        if (iph1 == NULL) {
2203                iph2->retry_checkph1 = lcconf->retry_checkph1;
2204                sched_schedule(&iph2->sce, 1, isakmp_chkph1there_stub);
2205                plog(LLV_INFO, LOCATION, NULL,
2206                        "IPsec-SA request for %s queued "
2207                        "due to no phase1 found.\n",
2208                        saddrwop2str(iph2->dst));
2209
2210                /* start phase 1 negotiation as a initiator. */
2211                if (isakmp_ph1begin_i(rmconf, iph2->dst, iph2->src) == NULL) {
2212                        sched_cancel(&iph2->sce);
2213                        return -1;
2214                }
2215
2216                return 0;
2217                /*NOTREACHED*/
2218        }
2219
2220        /* found ISAKMP-SA, but on negotiation. */
2221        if (iph1->status < PHASE1ST_ESTABLISHED) {
2222                iph2->retry_checkph1 = lcconf->retry_checkph1;
2223                sched_schedule(&iph2->sce, 1, isakmp_chkph1there_stub);
2224                plog(LLV_INFO, LOCATION, iph2->dst,
2225                        "request for establishing IPsec-SA was queued "
2226                        "due to no phase1 found.\n");
2227                return 0;
2228                /*NOTREACHED*/
2229        }
2230
2231        /* found established ISAKMP-SA */
2232        /* i.e. iph1->status == PHASE1ST_ESTABLISHED */
2233
2234        /* found ISAKMP-SA. */
2235        plog(LLV_DEBUG, LOCATION, NULL, "begin QUICK mode.\n");
2236
2237        /* begin quick mode */
2238        if (isakmp_ph2begin_i(iph1, iph2))
2239                return -1;
2240
2241        return 0;
2242}
2243
2244int
2245isakmp_get_sainfo(iph2, sp_out, sp_in)
2246        struct ph2handle *iph2;
2247        struct secpolicy *sp_out, *sp_in;
2248{
2249        struct remoteconf *conf;
2250        uint32_t remoteid = 0;
2251
2252        plog(LLV_DEBUG, LOCATION, NULL,
2253                "new acquire %s\n", spidx2str(&sp_out->spidx));
2254
2255        /* get sainfo */
2256        {
2257                vchar_t *idsrc, *iddst;
2258
2259                idsrc = ipsecdoi_sockaddr2id((struct sockaddr *)&sp_out->spidx.src,
2260                        sp_out->spidx.prefs, sp_out->spidx.ul_proto);
2261                if (idsrc == NULL) {
2262                        plog(LLV_ERROR, LOCATION, NULL,
2263                                "failed to get ID for %s\n",
2264                                spidx2str(&sp_out->spidx));
2265                        return -1;
2266                }
2267                iddst = ipsecdoi_sockaddr2id((struct sockaddr *)&sp_out->spidx.dst,
2268                        sp_out->spidx.prefd, sp_out->spidx.ul_proto);
2269                if (iddst == NULL) {
2270                        plog(LLV_ERROR, LOCATION, NULL,
2271                                "failed to get ID for %s\n",
2272                                spidx2str(&sp_out->spidx));
2273                        vfree(idsrc);
2274                        return -1;
2275                }
2276
2277                conf = getrmconf(iph2->dst, 0);
2278                if (conf != NULL)
2279                        remoteid = conf->ph1id;
2280                else
2281                        plog(LLV_DEBUG, LOCATION, NULL, "Warning: no valid rmconf !\n");
2282
2283                iph2->sainfo = getsainfo(idsrc, iddst, NULL, NULL, remoteid);
2284                vfree(idsrc);
2285                vfree(iddst);
2286                if (iph2->sainfo == NULL) {
2287                        plog(LLV_ERROR, LOCATION, NULL,
2288                                "failed to get sainfo.\n");
2289                        return -1;
2290                        /* XXX should use the algorithm list from register message */
2291                }
2292
2293                plog(LLV_DEBUG, LOCATION, NULL,
2294                        "selected sainfo: %s\n", sainfo2str(iph2->sainfo));
2295        }
2296
2297        if (set_proposal_from_policy(iph2, sp_out, sp_in) < 0) {
2298                plog(LLV_ERROR, LOCATION, NULL,
2299                        "failed to create saprop.\n");
2300                return -1;
2301        }
2302
2303        return 0;
2304}
2305
2306
2307/*
2308 * receive GETSPI from kernel.
2309 */
2310int
2311isakmp_post_getspi(iph2)
2312        struct ph2handle *iph2;
2313{
2314#ifdef ENABLE_STATS
2315        struct timeval start, end;
2316#endif
2317
2318        /* don't process it because there is no suitable phase1-sa. */
2319        if (iph2->ph1->status >= PHASE1ST_EXPIRED) {
2320                plog(LLV_ERROR, LOCATION, iph2->ph1->remote,
2321                        "the negotiation is stopped, "
2322                        "because there is no suitable ISAKMP-SA.\n");
2323                return -1;
2324        }
2325
2326#ifdef ENABLE_STATS
2327        gettimeofday(&start, NULL);
2328#endif
2329        if ((ph2exchange[etypesw2(ISAKMP_ETYPE_QUICK)]
2330                        [iph2->side]
2331                        [iph2->status])(iph2, NULL) != 0)
2332                return -1;
2333#ifdef ENABLE_STATS
2334        gettimeofday(&end, NULL);
2335        syslog(LOG_NOTICE, "%s(%s): %8.6f",
2336                "phase2",
2337                s_isakmp_state(ISAKMP_ETYPE_QUICK, iph2->side, iph2->status),
2338                timedelta(&start, &end));
2339#endif
2340
2341        return 0;
2342}
2343
2344/* called by scheduler */
2345void
2346isakmp_chkph1there_stub(p)
2347        struct sched *p;
2348{
2349        isakmp_chkph1there(container_of(p, struct ph2handle, sce));
2350}
2351
2352void
2353isakmp_chkph1there(iph2)
2354        struct ph2handle *iph2;
2355{
2356        struct ph1handle *iph1;
2357
2358        iph2->retry_checkph1--;
2359        if (iph2->retry_checkph1 < 0) {
2360                plog(LLV_ERROR, LOCATION, iph2->dst,
2361                        "phase2 negotiation failed "
2362                        "due to time up waiting for phase1. %s\n",
2363                        sadbsecas2str(iph2->dst, iph2->src,
2364                                iph2->satype, 0, 0));
2365                plog(LLV_INFO, LOCATION, NULL,
2366                        "delete phase 2 handler.\n");
2367
2368                /* send acquire to kernel as error */
2369                pk_sendeacquire(iph2);
2370
2371                remph2(iph2);
2372                delph2(iph2);
2373
2374                return;
2375        }
2376
2377        /* Search isakmp status table by address and port */
2378        iph1 = getph1byaddr(iph2->src, iph2->dst, 0);
2379
2380        /* XXX Even if ph1 as responder is there, should we not start
2381         * phase 2 negotiation ? */
2382        if (iph1 != NULL
2383         && iph1->status == PHASE1ST_ESTABLISHED) {
2384                /* found isakmp-sa */
2385
2386                plog(LLV_DEBUG2, LOCATION, NULL, "CHKPH1THERE: got a ph1 handler, setting ports.\n");
2387                plog(LLV_DEBUG2, LOCATION, NULL, "iph1->local: %s\n", saddr2str(iph1->local));
2388                plog(LLV_DEBUG2, LOCATION, NULL, "iph1->remote: %s\n", saddr2str(iph1->remote));
2389                plog(LLV_DEBUG2, LOCATION, NULL, "before:\n");
2390                plog(LLV_DEBUG2, LOCATION, NULL, "src: %s\n", saddr2str(iph2->src));
2391                plog(LLV_DEBUG2, LOCATION, NULL, "dst: %s\n", saddr2str(iph2->dst));
2392                set_port(iph2->src, extract_port(iph1->local));
2393                set_port(iph2->dst, extract_port(iph1->remote));
2394                plog(LLV_DEBUG2, LOCATION, NULL, "After:\n");
2395                plog(LLV_DEBUG2, LOCATION, NULL, "src: %s\n", saddr2str(iph2->src));
2396                plog(LLV_DEBUG2, LOCATION, NULL, "dst: %s\n", saddr2str(iph2->dst));
2397
2398                /* begin quick mode */
2399                (void)isakmp_ph2begin_i(iph1, iph2);
2400                return;
2401        }
2402
2403        plog(LLV_DEBUG2, LOCATION, NULL, "CHKPH1THERE: no established ph1 handler found\n");
2404
2405        /* no isakmp-sa found */
2406        sched_schedule(&iph2->sce, 1, isakmp_chkph1there_stub);
2407
2408        return;
2409}
2410
2411/* copy variable data into ALLOCATED buffer. */
2412caddr_t
2413isakmp_set_attr_v(buf, type, val, len)
2414        caddr_t buf;
2415        int type;
2416        caddr_t val;
2417        int len;
2418{
2419        struct isakmp_data *data;
2420
2421        data = (struct isakmp_data *)buf;
2422        data->type = htons((u_int16_t)type | ISAKMP_GEN_TLV);
2423        data->lorv = htons((u_int16_t)len);
2424        memcpy(data + 1, val, len);
2425
2426        return buf + sizeof(*data) + len;
2427}
2428
2429/* copy fixed length data into ALLOCATED buffer. */
2430caddr_t
2431isakmp_set_attr_l(buf, type, val)
2432        caddr_t buf;
2433        int type;
2434        u_int32_t val;
2435{
2436        struct isakmp_data *data;
2437
2438        data = (struct isakmp_data *)buf;
2439        data->type = htons((u_int16_t)type | ISAKMP_GEN_TV);
2440        data->lorv = htons((u_int16_t)val);
2441
2442        return buf + sizeof(*data);
2443}
2444
2445/* add a variable data attribute to the buffer by reallocating it. */
2446vchar_t *
2447isakmp_add_attr_v(buf0, type, val, len)
2448        vchar_t *buf0;
2449        int type;
2450        caddr_t val;
2451        int len;
2452{
2453        vchar_t *buf = NULL;
2454        struct isakmp_data *data;
2455        int tlen;
2456        int oldlen = 0;
2457
2458        tlen = sizeof(*data) + len;
2459
2460        if (buf0) {
2461                oldlen = buf0->l;
2462                buf = vrealloc(buf0, oldlen + tlen);
2463        } else
2464                buf = vmalloc(tlen);
2465        if (!buf) {
2466                plog(LLV_ERROR, LOCATION, NULL,
2467                        "failed to get a attribute buffer.\n");
2468                return NULL;
2469        }
2470
2471        data = (struct isakmp_data *)(buf->v + oldlen);
2472        data->type = htons((u_int16_t)type | ISAKMP_GEN_TLV);
2473        data->lorv = htons((u_int16_t)len);
2474        memcpy(data + 1, val, len);
2475
2476        return buf;
2477}
2478
2479/* add a fixed data attribute to the buffer by reallocating it. */
2480vchar_t *
2481isakmp_add_attr_l(buf0, type, val)
2482        vchar_t *buf0;
2483        int type;
2484        u_int32_t val;
2485{
2486        vchar_t *buf = NULL;
2487        struct isakmp_data *data;
2488        int tlen;
2489        int oldlen = 0;
2490
2491        tlen = sizeof(*data);
2492
2493        if (buf0) {
2494                oldlen = buf0->l;
2495                buf = vrealloc(buf0, oldlen + tlen);
2496        } else
2497                buf = vmalloc(tlen);
2498        if (!buf) {
2499                plog(LLV_ERROR, LOCATION, NULL,
2500                        "failed to get a attribute buffer.\n");
2501                return NULL;
2502        }
2503
2504        data = (struct isakmp_data *)(buf->v + oldlen);
2505        data->type = htons((u_int16_t)type | ISAKMP_GEN_TV);
2506        data->lorv = htons((u_int16_t)val);
2507
2508        return buf;
2509}
2510
2511/*
2512 * calculate cookie and set.
2513 */
2514int
2515isakmp_newcookie(place, remote, local)
2516        caddr_t place;
2517        struct sockaddr *remote;
2518        struct sockaddr *local;
2519{
2520        vchar_t *buf = NULL, *buf2 = NULL;
2521        char *p;
2522        int blen;
2523        int alen;
2524        caddr_t sa1, sa2;
2525        time_t t;
2526        int error = -1;
2527        u_short port;
2528
2529
2530        if (remote->sa_family != local->sa_family) {
2531                plog(LLV_ERROR, LOCATION, NULL,
2532                        "address family mismatch, remote:%d local:%d\n",
2533                        remote->sa_family, local->sa_family);
2534                goto end;
2535        }
2536        switch (remote->sa_family) {
2537        case AF_INET:
2538                alen = sizeof(struct in_addr);
2539                sa1 = (caddr_t)&((struct sockaddr_in *)remote)->sin_addr;
2540                sa2 = (caddr_t)&((struct sockaddr_in *)local)->sin_addr;
2541                break;
2542#ifdef INET6
2543        case AF_INET6:
2544                alen = sizeof(struct in6_addr);
2545                sa1 = (caddr_t)&((struct sockaddr_in6 *)remote)->sin6_addr;
2546                sa2 = (caddr_t)&((struct sockaddr_in6 *)local)->sin6_addr;
2547                break;
2548#endif
2549        default:
2550                plog(LLV_ERROR, LOCATION, NULL,
2551                        "invalid family: %d\n", remote->sa_family);
2552                goto end;
2553        }
2554        blen = (alen + sizeof(u_short)) * 2
2555                + sizeof(time_t) + lcconf->secret_size;
2556        buf = vmalloc(blen);
2557        if (buf == NULL) {
2558                plog(LLV_ERROR, LOCATION, NULL,
2559                        "failed to get a cookie.\n");
2560                goto end;
2561        }
2562        p = buf->v;
2563
2564        /* copy my address */
2565        memcpy(p, sa1, alen);
2566        p += alen;
2567        port = ((struct sockaddr_in *)remote)->sin_port;
2568        memcpy(p, &port, sizeof(u_short));
2569        p += sizeof(u_short);
2570
2571        /* copy target address */
2572        memcpy(p, sa2, alen);
2573        p += alen;
2574        port = ((struct sockaddr_in *)local)->sin_port;
2575        memcpy(p, &port, sizeof(u_short));
2576        p += sizeof(u_short);
2577
2578        /* copy time */
2579        t = time(0);
2580        memcpy(p, (caddr_t)&t, sizeof(t));
2581        p += sizeof(t);
2582
2583        /* copy random value */
2584        buf2 = eay_set_random(lcconf->secret_size);
2585        if (buf2 == NULL)
2586                goto end;
2587        memcpy(p, buf2->v, lcconf->secret_size);
2588        p += lcconf->secret_size;
2589        vfree(buf2);
2590
2591        buf2 = eay_sha1_one(buf);
2592        memcpy(place, buf2->v, sizeof(cookie_t));
2593
2594        sa1 = val2str(place, sizeof (cookie_t));
2595        plog(LLV_DEBUG, LOCATION, NULL, "new cookie:\n%s\n", sa1);
2596        racoon_free(sa1);
2597
2598        error = 0;
2599end:
2600        if (buf != NULL)
2601                vfree(buf);
2602        if (buf2 != NULL)
2603                vfree(buf2);
2604        return error;
2605}
2606
2607/*
2608 * save partner's(payload) data into phhandle.
2609 */
2610int
2611isakmp_p2ph(buf, gen)
2612        vchar_t **buf;
2613        struct isakmp_gen *gen;
2614{
2615        /* XXX to be checked in each functions for logging. */
2616        if (*buf) {
2617                plog(LLV_WARNING, LOCATION, NULL,
2618                        "ignore this payload, same payload type exist.\n");
2619                return -1;
2620        }
2621
2622        *buf = vmalloc(ntohs(gen->len) - sizeof(*gen));
2623        if (*buf == NULL) {
2624                plog(LLV_ERROR, LOCATION, NULL,
2625                        "failed to get buffer.\n");
2626                return -1;
2627        }
2628        memcpy((*buf)->v, gen + 1, (*buf)->l);
2629
2630        return 0;
2631}
2632
2633u_int32_t
2634isakmp_newmsgid2(iph1)
2635        struct ph1handle *iph1;
2636{
2637        u_int32_t msgid2;
2638
2639        do {
2640                msgid2 = eay_random();
2641        } while (getph2bymsgid(iph1, msgid2));
2642
2643        return msgid2;
2644}
2645
2646/*
2647 * set values into allocated buffer of isakmp header for phase 1
2648 */
2649static caddr_t
2650set_isakmp_header(vbuf, iph1, nptype, etype, flags, msgid)
2651        vchar_t *vbuf;
2652        struct ph1handle *iph1;
2653        int nptype;
2654        u_int8_t etype;
2655        u_int8_t flags;
2656        u_int32_t msgid;
2657{
2658        struct isakmp *isakmp;
2659
2660        if (vbuf->l < sizeof(*isakmp))
2661                return NULL;
2662
2663        isakmp = (struct isakmp *)vbuf->v;
2664
2665        memcpy(&isakmp->i_ck, &iph1->index.i_ck, sizeof(cookie_t));
2666        memcpy(&isakmp->r_ck, &iph1->index.r_ck, sizeof(cookie_t));
2667        isakmp->np = nptype;
2668        isakmp->v = iph1->version;
2669        isakmp->etype = etype;
2670        isakmp->flags = flags;
2671        isakmp->msgid = msgid;
2672        isakmp->len = htonl(vbuf->l);
2673
2674        return vbuf->v + sizeof(*isakmp);
2675}
2676
2677/*
2678 * set values into allocated buffer of isakmp header for phase 1
2679 */
2680caddr_t
2681set_isakmp_header1(vbuf, iph1, nptype)
2682        vchar_t *vbuf;
2683        struct ph1handle *iph1;
2684        int nptype;
2685{
2686        return set_isakmp_header (vbuf, iph1, nptype, iph1->etype, iph1->flags, iph1->msgid);
2687}
2688
2689/*
2690 * set values into allocated buffer of isakmp header for phase 2
2691 */
2692caddr_t
2693set_isakmp_header2(vbuf, iph2, nptype)
2694        vchar_t *vbuf;
2695        struct ph2handle *iph2;
2696        int nptype;
2697{
2698        return set_isakmp_header (vbuf, iph2->ph1, nptype, ISAKMP_ETYPE_QUICK, iph2->flags, iph2->msgid);
2699}
2700
2701/*
2702 * set values into allocated buffer of isakmp payload.
2703 */
2704caddr_t
2705set_isakmp_payload(buf, src, nptype)
2706        caddr_t buf;
2707        vchar_t *src;
2708        int nptype;
2709{
2710        struct isakmp_gen *gen;
2711        caddr_t p = buf;
2712
2713        plog(LLV_DEBUG, LOCATION, NULL, "add payload of len %zu, next type %d\n",
2714            src->l, nptype);
2715
2716        gen = (struct isakmp_gen *)p;
2717        gen->np = nptype;
2718        gen->len = htons(sizeof(*gen) + src->l);
2719        p += sizeof(*gen);
2720        memcpy(p, src->v, src->l);
2721        p += src->l;
2722
2723        return p;
2724}
2725
2726static int
2727etypesw1(etype)
2728        int etype;
2729{
2730        switch (etype) {
2731        case ISAKMP_ETYPE_IDENT:
2732                return 1;
2733        case ISAKMP_ETYPE_AGG:
2734                return 2;
2735        case ISAKMP_ETYPE_BASE:
2736                return 3;
2737        default:
2738                return 0;
2739        }
2740        /*NOTREACHED*/
2741}
2742
2743static int
2744etypesw2(etype)
2745        int etype;
2746{
2747        switch (etype) {
2748        case ISAKMP_ETYPE_QUICK:
2749                return 1;
2750        default:
2751                return 0;
2752        }
2753        /*NOTREACHED*/
2754}
2755
2756#ifdef HAVE_PRINT_ISAKMP_C
2757/* for print-isakmp.c */
2758char *snapend;
2759extern void isakmp_print __P((const u_char *, u_int, const u_char *));
2760
2761char *getname __P((const u_char *));
2762#ifdef INET6
2763char *getname6 __P((const u_char *));
2764#endif
2765int safeputchar __P((int));
2766
2767/*
2768 * Return a name for the IP address pointed to by ap.  This address
2769 * is assumed to be in network byte order.
2770 */
2771char *
2772getname(ap)
2773        const u_char *ap;
2774{
2775        struct sockaddr_in addr;
2776        static char ntop_buf[NI_MAXHOST];
2777
2778        memset(&addr, 0, sizeof(addr));
2779#ifndef __linux__
2780        addr.sin_len = sizeof(struct sockaddr_in);
2781#endif
2782        addr.sin_family = AF_INET;
2783        memcpy(&addr.sin_addr, ap, sizeof(addr.sin_addr));
2784        if (getnameinfo((struct sockaddr *)&addr, sizeof(addr),
2785                        ntop_buf, sizeof(ntop_buf), NULL, 0,
2786                        NI_NUMERICHOST | niflags))
2787                strlcpy(ntop_buf, "?", sizeof(ntop_buf));
2788
2789        return ntop_buf;
2790}
2791
2792#ifdef INET6
2793/*
2794 * Return a name for the IP6 address pointed to by ap.  This address
2795 * is assumed to be in network byte order.
2796 */
2797char *
2798getname6(ap)
2799        const u_char *ap;
2800{
2801        struct sockaddr_in6 addr;
2802        static char ntop_buf[NI_MAXHOST];
2803
2804        memset(&addr, 0, sizeof(addr));
2805        addr.sin6_len = sizeof(struct sockaddr_in6);
2806        addr.sin6_family = AF_INET6;
2807        memcpy(&addr.sin6_addr, ap, sizeof(addr.sin6_addr));
2808        if (getnameinfo((struct sockaddr *)&addr, addr.sin6_len,
2809                        ntop_buf, sizeof(ntop_buf), NULL, 0,
2810                        NI_NUMERICHOST | niflags))
2811                strlcpy(ntop_buf, "?", sizeof(ntop_buf));
2812
2813        return ntop_buf;
2814}
2815#endif /* INET6 */
2816
2817int
2818safeputchar(c)
2819        int c;
2820{
2821        unsigned char ch;
2822
2823        ch = (unsigned char)(c & 0xff);
2824        if (c < 0x80 && isprint(c))
2825                return printf("%c", c & 0xff);
2826        else
2827                return printf("\\%03o", c & 0xff);
2828}
2829
2830void
2831isakmp_printpacket(msg, from, my, decoded)
2832        vchar_t *msg;
2833        struct sockaddr *from;
2834        struct sockaddr *my;
2835        int decoded;
2836{
2837#ifdef YIPS_DEBUG
2838        struct timeval tv;
2839        int s;
2840        char hostbuf[NI_MAXHOST];
2841        char portbuf[NI_MAXSERV];
2842        struct isakmp *isakmp;
2843        vchar_t *buf;
2844#endif
2845
2846        if (loglevel < LLV_DEBUG)
2847                return;
2848
2849#ifdef YIPS_DEBUG
2850        plog(LLV_DEBUG, LOCATION, NULL, "begin.\n");
2851
2852        gettimeofday(&tv, NULL);
2853        s = tv.tv_sec % 3600;
2854        printf("%02d:%02d.%06u ", s / 60, s % 60, (u_int32_t)tv.tv_usec);
2855
2856        if (from) {
2857                if (getnameinfo(from, sysdep_sa_len(from), hostbuf, sizeof(hostbuf),
2858                                portbuf, sizeof(portbuf),
2859                                NI_NUMERICHOST | NI_NUMERICSERV | niflags)) {
2860                        strlcpy(hostbuf, "?", sizeof(hostbuf));
2861                        strlcpy(portbuf, "?", sizeof(portbuf));
2862                }
2863                printf("%s:%s", hostbuf, portbuf);
2864        } else
2865                printf("?");
2866        printf(" -> ");
2867        if (my) {
2868                if (getnameinfo(my, sysdep_sa_len(my), hostbuf, sizeof(hostbuf),
2869                                portbuf, sizeof(portbuf),
2870                                NI_NUMERICHOST | NI_NUMERICSERV | niflags)) {
2871                        strlcpy(hostbuf, "?", sizeof(hostbuf));
2872                        strlcpy(portbuf, "?", sizeof(portbuf));
2873                }
2874                printf("%s:%s", hostbuf, portbuf);
2875        } else
2876                printf("?");
2877        printf(": ");
2878
2879        buf = vdup(msg);
2880        if (!buf) {
2881                printf("(malloc fail)\n");
2882                return;
2883        }
2884        if (decoded) {
2885                isakmp = (struct isakmp *)buf->v;
2886                if (isakmp->flags & ISAKMP_FLAG_E) {
2887#if 0
2888                        int pad;
2889                        pad = *(u_char *)(buf->v + buf->l - 1);
2890                        if (buf->l < pad && 2 < vflag)
2891                                printf("(wrong padding)");
2892#endif
2893                        isakmp->flags &= ~ISAKMP_FLAG_E;
2894                }
2895        }
2896
2897        snapend = buf->v + buf->l;
2898        isakmp_print(buf->v, buf->l, NULL);
2899        vfree(buf);
2900        printf("\n");
2901        fflush(stdout);
2902
2903        return;
2904#endif
2905}
2906#endif /*HAVE_PRINT_ISAKMP_C*/
2907
2908int
2909copy_ph1addresses(iph1, rmconf, remote, local)
2910        struct ph1handle *iph1;
2911        struct remoteconf *rmconf;
2912        struct sockaddr *remote, *local;
2913{
2914        u_int16_t port;
2915
2916        /* address portion must be grabbed from real remote address "remote" */
2917        iph1->remote = dupsaddr(remote);
2918        if (iph1->remote == NULL)
2919                return -1;
2920
2921        /*
2922         * if remote has no port # (in case of initiator - from ACQUIRE msg)
2923         * - if remote.conf specifies port #, use that
2924         * - if remote.conf does not, use 500
2925         * if remote has port # (in case of responder - from recvfrom(2))
2926         * respect content of "remote".
2927         */
2928        if (extract_port(iph1->remote) == 0) {
2929                port = 0;
2930                if (rmconf != NULL)
2931                        port = extract_port(rmconf->remote);
2932                if (port == 0)
2933                        port = PORT_ISAKMP;
2934                set_port(iph1->remote, port);
2935        }
2936
2937        if (local == NULL)
2938                iph1->local = getlocaladdr(iph1->remote);
2939        else
2940                iph1->local = dupsaddr(local);
2941        if (iph1->local == NULL)
2942                return -1;
2943
2944        if (extract_port(iph1->local) == 0) {
2945                port = myaddr_getsport(iph1->local);
2946                if (port == 0)
2947                        port = PORT_ISAKMP;
2948                set_port(iph1->local, port);
2949        }
2950
2951#ifdef ENABLE_NATT
2952        if (extract_port(iph1->local) == lcconf->port_isakmp_natt) {
2953                plog(LLV_DEBUG, LOCATION, NULL, "Marking ports as changed\n");
2954                iph1->natt_flags |= NAT_ADD_NON_ESP_MARKER;
2955        }
2956#endif
2957
2958        return 0;
2959}
2960
2961static int
2962nostate1(iph1, msg)
2963        struct ph1handle *iph1;
2964        vchar_t *msg;
2965{
2966        plog(LLV_ERROR, LOCATION, iph1->remote, "wrong state %u.\n",
2967                        iph1->status);
2968        return -1;
2969}
2970
2971static int
2972nostate2(iph2, msg)
2973        struct ph2handle *iph2;
2974        vchar_t *msg;
2975{
2976        plog(LLV_ERROR, LOCATION, iph2->ph1->remote, "wrong state %u.\n",
2977                iph2->status);
2978        return -1;
2979}
2980
2981void
2982log_ph1established(iph1)
2983        const struct ph1handle *iph1;
2984{
2985        char *src, *dst;
2986
2987        src = racoon_strdup(saddr2str(iph1->local));
2988        dst = racoon_strdup(saddr2str(iph1->remote));
2989        STRDUP_FATAL(src);
2990        STRDUP_FATAL(dst);
2991
2992        plog(LLV_INFO, LOCATION, NULL,
2993                "ISAKMP-SA established %s-%s spi:%s\n",
2994                src, dst,
2995                isakmp_pindex(&iph1->index, 0));
2996
2997        evt_phase1(iph1, EVT_PHASE1_UP, NULL);
2998        if(!iph1->rmconf->mode_cfg)
2999                evt_phase1(iph1, EVT_PHASE1_MODE_CFG, NULL);
3000
3001        racoon_free(src);
3002        racoon_free(dst);
3003
3004        return;
3005}
3006
3007struct payload_list *
3008isakmp_plist_append_full (struct payload_list *plist, vchar_t *payload,
3009                          u_int8_t payload_type, u_int8_t free_payload)
3010{
3011        if (! plist) {
3012                plist = racoon_malloc (sizeof (struct payload_list));
3013                plist->prev = NULL;
3014        }
3015        else {
3016                plist->next = racoon_malloc (sizeof (struct payload_list));
3017                plist->next->prev = plist;
3018                plist = plist->next;
3019        }
3020
3021        plist->next = NULL;
3022        plist->payload = payload;
3023        plist->payload_type = payload_type;
3024        plist->free_payload = free_payload;
3025
3026        return plist;
3027}
3028
3029vchar_t *
3030isakmp_plist_set_all (struct payload_list **plist, struct ph1handle *iph1)
3031{
3032        struct payload_list *ptr = *plist, *first;
3033        size_t tlen = sizeof (struct isakmp), n = 0;
3034        vchar_t *buf = NULL;
3035        char *p;
3036
3037        /* Seek to the first item.  */
3038        while (ptr->prev) ptr = ptr->prev;
3039        first = ptr;
3040
3041        /* Compute the whole length.  */
3042        while (ptr) {
3043                tlen += ptr->payload->l + sizeof (struct isakmp_gen);
3044                ptr = ptr->next;
3045        }
3046
3047        buf = vmalloc(tlen);
3048        if (buf == NULL) {
3049                plog(LLV_ERROR, LOCATION, NULL,
3050                        "failed to get buffer to send.\n");
3051                goto end;
3052        }
3053
3054        ptr = first;
3055
3056        p = set_isakmp_header1(buf, iph1, ptr->payload_type);
3057        if (p == NULL)
3058                goto end;
3059
3060        while (ptr)
3061        {
3062                p = set_isakmp_payload (p, ptr->payload, ptr->next ? ptr->next->payload_type : ISAKMP_NPTYPE_NONE);
3063                first = ptr;
3064                ptr = ptr->next;
3065                if (first->free_payload)
3066                        vfree(first->payload);
3067                racoon_free (first);
3068                /* ptr->prev = NULL; first = NULL; ... omitted.  */
3069                n++;
3070        }
3071
3072        *plist = NULL;
3073
3074        return buf;
3075end:
3076        if (buf != NULL)
3077                vfree(buf);
3078        return NULL;
3079}
3080
3081#ifdef ENABLE_FRAG
3082int
3083frag_handler(iph1, msg, remote, local)
3084        struct ph1handle *iph1;
3085        vchar_t *msg;
3086        struct sockaddr *remote;
3087        struct sockaddr *local;
3088{
3089        vchar_t *newmsg;
3090
3091        if (isakmp_frag_extract(iph1, msg) == 1) {
3092                if ((newmsg = isakmp_frag_reassembly(iph1)) == NULL) {
3093                        plog(LLV_ERROR, LOCATION, remote,
3094                            "Packet reassembly failed\n");
3095                        return -1;
3096                }
3097                return isakmp_main(newmsg, remote, local);
3098        }
3099
3100        return 0;
3101}
3102#endif
3103
3104void
3105script_hook(iph1, script)
3106        struct ph1handle *iph1;
3107        int script;
3108{
3109#define IP_MAX 40
3110#define PORT_MAX 6
3111        char addrstr[IP_MAX];
3112        char portstr[PORT_MAX];
3113        char **envp = NULL;
3114        int envc = 1;
3115        char **c;
3116
3117        if (iph1 == NULL ||
3118                iph1->rmconf == NULL ||
3119                iph1->rmconf->script[script] == NULL)
3120                return;
3121
3122#ifdef ENABLE_HYBRID
3123        (void)isakmp_cfg_setenv(iph1, &envp, &envc);
3124#endif
3125
3126        /* local address */
3127        GETNAMEINFO(iph1->local, addrstr, portstr);
3128
3129        if (script_env_append(&envp, &envc, "LOCAL_ADDR", addrstr) != 0) {
3130                plog(LLV_ERROR, LOCATION, NULL, "Cannot set LOCAL_ADDR\n");
3131                goto out;
3132        }
3133
3134        if (script_env_append(&envp, &envc, "LOCAL_PORT", portstr) != 0) {
3135                plog(LLV_ERROR, LOCATION, NULL, "Cannot set LOCAL_PORT\n");
3136                goto out;
3137        }
3138
3139        /* Peer address */
3140        if (iph1->remote != NULL) {
3141                GETNAMEINFO(iph1->remote, addrstr, portstr);
3142
3143                if (script_env_append(&envp, &envc, 
3144                    "REMOTE_ADDR", addrstr) != 0) {
3145                        plog(LLV_ERROR, LOCATION, NULL, 
3146                            "Cannot set REMOTE_ADDR\n");
3147                        goto out;
3148                }
3149
3150                if (script_env_append(&envp, &envc, 
3151                    "REMOTE_PORT", portstr) != 0) {
3152                        plog(LLV_ERROR, LOCATION, NULL, 
3153                            "Cannot set REMOTEL_PORT\n");
3154                        goto out;
3155                }
3156        }
3157
3158        /* Peer identity. */
3159        if (iph1->id_p != NULL) {
3160                if (script_env_append(&envp, &envc, "REMOTE_ID",
3161                                      ipsecdoi_id2str(iph1->id_p)) != 0) {
3162                        plog(LLV_ERROR, LOCATION, NULL,
3163                             "Cannot set REMOTE_ID\n");
3164                        goto out;
3165                }
3166        }
3167
3168        if (privsep_script_exec(iph1->rmconf->script[script]->v, 
3169            script, envp) != 0) 
3170                plog(LLV_ERROR, LOCATION, NULL, 
3171                    "Script %s execution failed\n", script_names[script]);
3172
3173out:
3174        for (c = envp; *c; c++)
3175                racoon_free(*c);
3176
3177        racoon_free(envp);
3178
3179        return;
3180}
3181
3182int
3183script_env_append(envp, envc, name, value)
3184        char ***envp;
3185        int *envc;
3186        char *name;
3187        char *value;
3188{
3189        char *envitem;
3190        char **newenvp;
3191        int newenvc;
3192
3193        envitem = racoon_malloc(strlen(name) + 1 + strlen(value) + 1);
3194        if (envitem == NULL) {
3195                plog(LLV_ERROR, LOCATION, NULL,
3196                    "Cannot allocate memory: %s\n", strerror(errno));
3197                return -1;
3198        }
3199        sprintf(envitem, "%s=%s", name, value);
3200
3201        newenvc = (*envc) + 1;
3202        newenvp = racoon_realloc(*envp, newenvc * sizeof(char *));
3203        if (newenvp == NULL) {
3204                plog(LLV_ERROR, LOCATION, NULL,
3205                    "Cannot allocate memory: %s\n", strerror(errno));
3206                racoon_free(envitem);
3207                return -1;
3208        }
3209
3210        newenvp[newenvc - 2] = envitem;
3211        newenvp[newenvc - 1] = NULL;
3212
3213        *envp = newenvp;
3214        *envc = newenvc;
3215        return 0;
3216}
3217
3218int
3219script_exec(script, name, envp)
3220        char *script;
3221        int name;
3222        char *const envp[];
3223{
3224        char *argv[] = { NULL, NULL, NULL };
3225
3226        argv[0] = script;
3227        argv[1] = script_names[name];
3228        argv[2] = NULL;
3229
3230        switch (fork()) {
3231        case 0:
3232                execve(argv[0], argv, envp);
3233                plog(LLV_ERROR, LOCATION, NULL,
3234                    "execve(\"%s\") failed: %s\n",
3235                    argv[0], strerror(errno));
3236                _exit(1);
3237                break;
3238        case -1:
3239                plog(LLV_ERROR, LOCATION, NULL,
3240                    "Cannot fork: %s\n", strerror(errno));
3241                return -1;
3242                break;
3243        default:
3244                break;
3245        }
3246        return 0;
3247
3248}
3249
3250void
3251purge_remote(iph1)
3252        struct ph1handle *iph1;
3253{
3254        vchar_t *buf = NULL;
3255        struct sadb_msg *msg, *next, *end;
3256        struct sadb_sa *sa;
3257        struct sockaddr *src, *dst;
3258        caddr_t mhp[SADB_EXT_MAX + 1];
3259        u_int proto_id;
3260        struct ph2handle *iph2;
3261        struct ph1handle *new_iph1;
3262
3263        plog(LLV_INFO, LOCATION, NULL,
3264                 "purging ISAKMP-SA spi=%s.\n",
3265                 isakmp_pindex(&(iph1->index), iph1->msgid));
3266
3267        /* Mark as expired. */
3268        iph1->status = PHASE1ST_EXPIRED;
3269
3270        /* Check if we have another, still valid, phase1 SA. */
3271        new_iph1 = getph1(iph1, iph1->local, iph1->remote, GETPH1_F_ESTABLISHED);
3272
3273        /*
3274         * Delete all orphaned or binded to the deleting ph1handle phase2 SAs.
3275         * Keep all others phase2 SAs.
3276         */
3277        buf = pfkey_dump_sadb(SADB_SATYPE_UNSPEC);
3278        if (buf == NULL) {
3279                plog(LLV_DEBUG, LOCATION, NULL,
3280                        "pfkey_dump_sadb returned nothing.\n");
3281                return;
3282        }
3283
3284        msg = (struct sadb_msg *)buf->v;
3285        end = (struct sadb_msg *)(buf->v + buf->l);
3286
3287        while (msg < end) {
3288                if ((msg->sadb_msg_len << 3) < sizeof(*msg))
3289                        break;
3290                next = (struct sadb_msg *)((caddr_t)msg + (msg->sadb_msg_len << 3));
3291                if (msg->sadb_msg_type != SADB_DUMP) {
3292                        msg = next;
3293                        continue;
3294                }
3295
3296                if (pfkey_align(msg, mhp) || pfkey_check(mhp)) {
3297                        plog(LLV_ERROR, LOCATION, NULL,
3298                                "pfkey_check (%s)\n", ipsec_strerror());
3299                        msg = next;
3300                        continue;
3301                }
3302
3303                sa = (struct sadb_sa *)(mhp[SADB_EXT_SA]);
3304                if (!sa ||
3305                    !mhp[SADB_EXT_ADDRESS_SRC] ||
3306                    !mhp[SADB_EXT_ADDRESS_DST]) {
3307                        msg = next;
3308                        continue;
3309                }
3310                pk_fixup_sa_addresses(mhp);
3311                src = PFKEY_ADDR_SADDR(mhp[SADB_EXT_ADDRESS_SRC]);
3312                dst = PFKEY_ADDR_SADDR(mhp[SADB_EXT_ADDRESS_DST]);
3313
3314                if (sa->sadb_sa_state != SADB_SASTATE_LARVAL &&
3315                    sa->sadb_sa_state != SADB_SASTATE_MATURE &&
3316                    sa->sadb_sa_state != SADB_SASTATE_DYING) {
3317                        msg = next;
3318                        continue;
3319                }
3320
3321                /*
3322                 * check in/outbound SAs.
3323                 * Select only SAs where src == local and dst == remote (outgoing)
3324                 * or src == remote and dst == local (incoming).
3325                 */
3326                if ((cmpsaddr(iph1->local, src) != CMPSADDR_MATCH ||
3327                     cmpsaddr(iph1->remote, dst) != CMPSADDR_MATCH) &&
3328                    (cmpsaddr(iph1->local, dst) != CMPSADDR_MATCH ||
3329                     cmpsaddr(iph1->remote, src) != CMPSADDR_MATCH)) {
3330                        msg = next;
3331                        continue;
3332                }
3333
3334                proto_id = pfkey2ipsecdoi_proto(msg->sadb_msg_satype);
3335                iph2 = getph2bysaidx(src, dst, proto_id, sa->sadb_sa_spi);
3336
3337                /* Check if there is another valid ISAKMP-SA */
3338                if (new_iph1 != NULL) {
3339
3340                        if (iph2 == NULL) {
3341                                /* No handler... still send a pfkey_delete message, but log this !*/
3342                                plog(LLV_INFO, LOCATION, NULL,
3343                                        "Unknown IPsec-SA spi=%u, hmmmm?\n",
3344                                        ntohl(sa->sadb_sa_spi));
3345                        }else{
3346
3347                                /*
3348                                 * If we have a new ph1, do not purge IPsec-SAs binded
3349                                 *  to a different ISAKMP-SA
3350                                 */
3351                                if (iph2->ph1 != NULL && iph2->ph1 != iph1){
3352                                        msg = next;
3353                                        continue;
3354                                }
3355
3356                                /* If the ph2handle is established, do not purge IPsec-SA */
3357                                if (iph2->status == PHASE2ST_ESTABLISHED ||
3358                                        iph2->status == PHASE2ST_EXPIRED) {
3359
3360                                        plog(LLV_INFO, LOCATION, NULL,
3361                                                 "keeping IPsec-SA spi=%u - found valid ISAKMP-SA spi=%s.\n",
3362                                                 ntohl(sa->sadb_sa_spi),
3363                                                 isakmp_pindex(&(new_iph1->index), new_iph1->msgid));
3364                                        msg = next;
3365                                        continue;
3366                                }
3367                        }
3368                }
3369
3370
3371                pfkey_send_delete(lcconf->sock_pfkey,
3372                                  msg->sadb_msg_satype,
3373                                  IPSEC_MODE_ANY,
3374                                  src, dst, sa->sadb_sa_spi);
3375
3376                /* delete a relative phase 2 handle. */
3377                if (iph2 != NULL) {
3378                        delete_spd(iph2, 0);
3379                        remph2(iph2);
3380                        delph2(iph2);
3381                }
3382
3383                plog(LLV_INFO, LOCATION, NULL,
3384                         "purged IPsec-SA spi=%u.\n",
3385                         ntohl(sa->sadb_sa_spi));
3386
3387                msg = next;
3388        }
3389
3390        if (buf)
3391                vfree(buf);
3392
3393        /* Mark the phase1 handler as EXPIRED */
3394        plog(LLV_INFO, LOCATION, NULL,
3395                 "purged ISAKMP-SA spi=%s.\n",
3396                 isakmp_pindex(&(iph1->index), iph1->msgid));
3397
3398        isakmp_ph1delete(iph1);
3399}
3400
3401void
3402delete_spd(iph2, created)
3403        struct ph2handle *iph2;
3404        u_int64_t created;
3405{
3406        struct policyindex spidx;
3407        struct sockaddr_storage addr;
3408        u_int8_t pref;
3409        struct sockaddr *src;
3410        struct sockaddr *dst;
3411        int error;
3412        int idi2type = 0;/* switch whether copy IDs into id[src,dst]. */
3413
3414        if (iph2 == NULL)
3415                return;
3416
3417        /* Delete the SPD entry if we generated it
3418         */
3419        if (! iph2->generated_spidx )
3420                return;
3421
3422        src = iph2->src;
3423        dst = iph2->dst;
3424
3425        plog(LLV_INFO, LOCATION, NULL,
3426                 "deleting a generated policy.\n");
3427
3428        memset(&spidx, 0, sizeof(spidx));
3429        iph2->spidx_gen = (caddr_t )&spidx;
3430
3431        /* make inbound policy */
3432        iph2->src = dst;
3433        iph2->dst = src;
3434        spidx.dir = IPSEC_DIR_INBOUND;
3435        spidx.ul_proto = 0;
3436
3437        /*
3438         * Note: code from get_proposal_r
3439         */
3440
3441#define _XIDT(d) ((struct ipsecdoi_id_b *)(d)->v)->type
3442
3443        /*
3444         * make destination address in spidx from either ID payload
3445         * or phase 1 address into a address in spidx.
3446         */
3447        if (iph2->id != NULL
3448                && (_XIDT(iph2->id) == IPSECDOI_ID_IPV4_ADDR
3449                        || _XIDT(iph2->id) == IPSECDOI_ID_IPV6_ADDR
3450                        || _XIDT(iph2->id) == IPSECDOI_ID_IPV4_ADDR_SUBNET
3451                        || _XIDT(iph2->id) == IPSECDOI_ID_IPV6_ADDR_SUBNET)) {
3452                /* get a destination address of a policy */
3453                error = ipsecdoi_id2sockaddr(iph2->id,
3454                                                                         (struct sockaddr *)&spidx.dst,
3455                                                                         &spidx.prefd, &spidx.ul_proto);
3456                if (error)
3457                        goto purge;
3458
3459#ifdef INET6
3460                /*
3461                 * get scopeid from the SA address.
3462                 * note that the phase 1 source address is used as
3463                 * a destination address to search for a inbound
3464                 * policy entry because rcoon is responder.
3465                 */
3466                if (_XIDT(iph2->id) == IPSECDOI_ID_IPV6_ADDR) {
3467                        if ((error =
3468                                 setscopeid((struct sockaddr *)&spidx.dst,
3469                                                        iph2->src)) != 0)
3470                                goto purge;
3471                }
3472#endif
3473
3474                if (_XIDT(iph2->id) == IPSECDOI_ID_IPV4_ADDR
3475                        || _XIDT(iph2->id) == IPSECDOI_ID_IPV6_ADDR)
3476                        idi2type = _XIDT(iph2->id);
3477
3478        } else {
3479
3480                plog(LLV_DEBUG, LOCATION, NULL,
3481                         "get a destination address of SP index "
3482                         "from phase1 address "
3483                         "due to no ID payloads found "
3484                         "OR because ID type is not address.\n");
3485
3486                /*
3487                 * copy the SOURCE address of IKE into the
3488                 * DESTINATION address of the key to search the
3489                 * SPD because the direction of policy is inbound.
3490                 */
3491                memcpy(&spidx.dst, iph2->src, sysdep_sa_len(iph2->src));
3492                switch (spidx.dst.ss_family) {
3493                case AF_INET:
3494                        spidx.prefd =
3495                                sizeof(struct in_addr) << 3;
3496                        break;
3497#ifdef INET6
3498                case AF_INET6:
3499                        spidx.prefd =
3500                                sizeof(struct in6_addr) << 3;
3501                        break;
3502#endif
3503                default:
3504                        spidx.prefd = 0;
3505                        break;
3506                }
3507        }
3508
3509                /* make source address in spidx */
3510        if (iph2->id_p != NULL
3511                && (_XIDT(iph2->id_p) == IPSECDOI_ID_IPV4_ADDR
3512                        || _XIDT(iph2->id_p) == IPSECDOI_ID_IPV6_ADDR
3513                        || _XIDT(iph2->id_p) == IPSECDOI_ID_IPV4_ADDR_SUBNET
3514                        || _XIDT(iph2->id_p) == IPSECDOI_ID_IPV6_ADDR_SUBNET)) {
3515                /* get a source address of inbound SA */
3516                error = ipsecdoi_id2sockaddr(iph2->id_p,
3517                                             (struct sockaddr *)&spidx.src,
3518                                             &spidx.prefs, &spidx.ul_proto);
3519                if (error)
3520                        goto purge;
3521
3522#ifdef INET6
3523                /*
3524                 * get scopeid from the SA address.
3525                 * for more detail, see above of this function.
3526                 */
3527                if (_XIDT(iph2->id_p) == IPSECDOI_ID_IPV6_ADDR) {
3528                        error =
3529                                setscopeid((struct sockaddr *)&spidx.src,
3530                                                   iph2->dst);
3531                        if (error)
3532                                goto purge;
3533                }
3534#endif
3535
3536                /* make sa_[src,dst] if both ID types are IP address and same */
3537                if (_XIDT(iph2->id_p) == idi2type
3538                        && spidx.dst.ss_family == spidx.src.ss_family) {
3539                        iph2->sa_src =
3540                                dupsaddr((struct sockaddr *)&spidx.dst);
3541                        if (iph2->sa_src == NULL) {
3542                                plog(LLV_ERROR, LOCATION, NULL,
3543                                         "allocation failed\n");
3544                                goto purge;
3545                        }
3546                        iph2->sa_dst =
3547                                dupsaddr((struct sockaddr *)&spidx.src);
3548                        if (iph2->sa_dst == NULL) {
3549                                plog(LLV_ERROR, LOCATION, NULL,
3550                                         "allocation failed\n");
3551                                goto purge;
3552                        }
3553                }
3554
3555        } else {
3556                plog(LLV_DEBUG, LOCATION, NULL,
3557                         "get a source address of SP index "
3558                         "from phase1 address "
3559                         "due to no ID payloads found "
3560                         "OR because ID type is not address.\n");
3561
3562                /* see above comment. */
3563                memcpy(&spidx.src, iph2->dst, sysdep_sa_len(iph2->dst));
3564                switch (spidx.src.ss_family) {
3565                case AF_INET:
3566                        spidx.prefs =
3567                                sizeof(struct in_addr) << 3;
3568                        break;
3569#ifdef INET6
3570                case AF_INET6:
3571                        spidx.prefs =
3572                                sizeof(struct in6_addr) << 3;
3573                        break;
3574#endif
3575                default:
3576                        spidx.prefs = 0;
3577                        break;
3578                }
3579        }
3580
3581#undef _XIDT
3582
3583        plog(LLV_DEBUG, LOCATION, NULL,
3584                 "get a src address from ID payload "
3585                 "%s prefixlen=%u ul_proto=%u\n",
3586                 saddr2str((struct sockaddr *)&spidx.src),
3587                 spidx.prefs, spidx.ul_proto);
3588        plog(LLV_DEBUG, LOCATION, NULL,
3589                 "get dst address from ID payload "
3590                 "%s prefixlen=%u ul_proto=%u\n",
3591                 saddr2str((struct sockaddr *)&spidx.dst),
3592                 spidx.prefd, spidx.ul_proto);
3593
3594        /*
3595         * convert the ul_proto if it is 0
3596         * because 0 in ID payload means a wild card.
3597         */
3598        if (spidx.ul_proto == 0)
3599                spidx.ul_proto = IPSEC_ULPROTO_ANY;
3600
3601#undef _XIDT
3602
3603        /* Check if the generated SPD has the same timestamp as the SA.
3604         * If timestamps are different, this means that the SPD entry has been
3605         * refreshed by another SA, and should NOT be deleted with the current SA.
3606         */
3607        if( created ){
3608                struct secpolicy *p;
3609
3610                p = getsp(&spidx);
3611                if(p != NULL){
3612                        /* just do no test if p is NULL, because this probably just means
3613                         * that the policy has already be deleted for some reason.
3614                         */
3615                        if(p->spidx.created != created)
3616                                goto purge;
3617                }
3618        }
3619
3620        /* End of code from get_proposal_r
3621         */
3622
3623        if (pk_sendspddelete(iph2) < 0) {
3624                plog(LLV_ERROR, LOCATION, NULL,
3625                         "pfkey spddelete(inbound) failed.\n");
3626        }else{
3627                plog(LLV_DEBUG, LOCATION, NULL,
3628                         "pfkey spddelete(inbound) sent.\n");
3629        }
3630
3631#ifdef HAVE_POLICY_FWD
3632        /* make forward policy if required */
3633        if (tunnel_mode_prop(iph2->approval)) {
3634                spidx.dir = IPSEC_DIR_FWD;
3635                if (pk_sendspddelete(iph2) < 0) {
3636                        plog(LLV_ERROR, LOCATION, NULL,
3637                                 "pfkey spddelete(forward) failed.\n");
3638                }else{
3639                        plog(LLV_DEBUG, LOCATION, NULL,
3640                                 "pfkey spddelete(forward) sent.\n");
3641                }
3642        }
3643#endif
3644
3645        /* make outbound policy */
3646        iph2->src = src;
3647        iph2->dst = dst;
3648        spidx.dir = IPSEC_DIR_OUTBOUND;
3649        addr = spidx.src;
3650        spidx.src = spidx.dst;
3651        spidx.dst = addr;
3652        pref = spidx.prefs;
3653        spidx.prefs = spidx.prefd;
3654        spidx.prefd = pref;
3655
3656        if (pk_sendspddelete(iph2) < 0) {
3657                plog(LLV_ERROR, LOCATION, NULL,
3658                         "pfkey spddelete(outbound) failed.\n");
3659        }else{
3660                plog(LLV_DEBUG, LOCATION, NULL,
3661                         "pfkey spddelete(outbound) sent.\n");
3662        }
3663purge:
3664        iph2->spidx_gen=NULL;
3665}
3666
3667
3668#ifdef INET6
3669u_int32_t
3670setscopeid(sp_addr0, sa_addr0)
3671        struct sockaddr *sp_addr0, *sa_addr0;
3672{
3673        struct sockaddr_in6 *sp_addr, *sa_addr;
3674
3675        sp_addr = (struct sockaddr_in6 *)sp_addr0;
3676        sa_addr = (struct sockaddr_in6 *)sa_addr0;
3677
3678        if (!IN6_IS_ADDR_LINKLOCAL(&sp_addr->sin6_addr)
3679         && !IN6_IS_ADDR_SITELOCAL(&sp_addr->sin6_addr)
3680         && !IN6_IS_ADDR_MULTICAST(&sp_addr->sin6_addr))
3681                return 0;
3682
3683        /* this check should not be here ? */
3684        if (sa_addr->sin6_family != AF_INET6) {
3685                plog(LLV_ERROR, LOCATION, NULL,
3686                        "can't get scope ID: family mismatch\n");
3687                return -1;
3688        }
3689
3690        if (!IN6_IS_ADDR_LINKLOCAL(&sa_addr->sin6_addr)) {
3691                plog(LLV_ERROR, LOCATION, NULL,
3692                        "scope ID is not supported except of lladdr.\n");
3693                return -1;
3694        }
3695
3696        sp_addr->sin6_scope_id = sa_addr->sin6_scope_id;
3697
3698        return 0;
3699}
3700#endif
Note: See TracBrowser for help on using the repository browser.