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

5-freebsd-12
Last change on this file since b376ae1 was b376ae1, checked in by Christian Mauderer <christian.mauderer@…>, on May 3, 2018 at 12:15:11 PM

ipsec-tools: Port libipsec, setkey and racoon.

Note that this replaces the libipsec from FreeBSD with the one provided
by ipsec-tools.

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