source: packages/net/ipsec-tools/patches/004-opennhrp.patch @ 20544

Last change on this file since 20544 was 20544, checked in by florian, 6 years ago

[package] add GRE support to ipsec-tools, so that opennhrp can work (#6926)

File size: 43.0 KB
  • src/racoon/admin.c

    old new  
    7676#include "evt.h" 
    7777#include "pfkey.h" 
    7878#include "ipsec_doi.h" 
     79#include "policy.h" 
    7980#include "admin.h" 
    8081#include "admin_var.h" 
    8182#include "isakmp_inf.h" 
     
    147148                goto end; 
    148149        } 
    149150 
    150         if (com.ac_cmd == ADMIN_RELOAD_CONF) { 
    151                 /* reload does not work at all! */ 
    152                 signal_handler(SIGHUP); 
    153                 goto end; 
    154         } 
     151        plog(LLV_DEBUG, LOCATION, NULL, 
     152             "[%d] admin connection established\n", so2); 
    155153 
    156154        error = admin_process(so2, combuf); 
    157155 
    158     end: 
    159         (void)close(so2); 
     156end: 
     157        if (error != -2) { 
     158                plog(LLV_DEBUG, LOCATION, NULL, 
     159                     "[%d] admin connection closed\n", so2); 
     160                (void)close(so2); 
     161        } 
     162 
    160163        if (combuf) 
    161164                racoon_free(combuf); 
    162165 
     
    177180        vchar_t *key = NULL; 
    178181        int idtype = 0; 
    179182        int error = -1; 
     183        int send_events = 0; 
     184        struct evt_listener_list *event_list = NULL; 
    180185 
    181186        com->ac_errno = 0; 
    182187 
     
    208213        } 
    209214 
    210215        case ADMIN_SHOW_EVT: 
    211                 /* It's not really an error, don't force racoonctl to quit */ 
    212                 if ((buf = evt_dump()) == NULL) 
    213                         com->ac_errno = 0;  
     216                send_events = 1; 
    214217                break; 
    215218 
    216219        case ADMIN_SHOW_SA: 
     
    393396        /* FALLTHROUGH */ 
    394397        case ADMIN_ESTABLISH_SA: 
    395398            { 
     399                struct admin_com_indexes *ndx; 
    396400                struct sockaddr *dst; 
    397401                struct sockaddr *src; 
    398                 src = (struct sockaddr *) 
    399                         &((struct admin_com_indexes *) 
    400                             ((caddr_t)com + sizeof(*com)))->src; 
    401                 dst = (struct sockaddr *) 
    402                         &((struct admin_com_indexes *) 
    403                             ((caddr_t)com + sizeof(*com)))->dst; 
     402 
     403                ndx = (struct admin_com_indexes *) ((caddr_t)com + sizeof(*com)); 
     404                src = (struct sockaddr *) &ndx->src; 
     405                dst = (struct sockaddr *) &ndx->dst; 
    404406 
    405407                switch (com->ac_proto) { 
    406408                case ADMIN_PROTO_ISAKMP: { 
     409                        struct ph1handle *ph1; 
    407410                        struct remoteconf *rmconf; 
    408411                        struct sockaddr *remote = NULL; 
    409412                        struct sockaddr *local = NULL; 
     
    411414 
    412415                        com->ac_errno = -1; 
    413416 
     417                        /* connected already? */ 
     418                        ph1 = getph1byaddrwop(src, dst); 
     419                        if (ph1 != NULL) { 
     420                                event_list = &ph1->evt_listeners; 
     421                                if (ph1->status == PHASE1ST_ESTABLISHED) 
     422                                        com->ac_errno = EEXIST; 
     423                                else 
     424                                        com->ac_errno = 0; 
     425                                break; 
     426                        } 
     427 
    414428                        /* search appropreate configuration */ 
    415429                        rmconf = getrmconf(dst); 
    416430                        if (rmconf == NULL) { 
     
    461475                                "%s\n", saddrwop2str(remote)); 
    462476 
    463477                        /* begin ident mode */ 
    464                         if (isakmp_ph1begin_i(rmconf, remote, local) < 0) 
     478                        ph1 = isakmp_ph1begin_i(rmconf, remote, local); 
     479                        if (ph1 == NULL) 
    465480                                goto out1; 
    466481 
     482                        event_list = &ph1->evt_listeners; 
    467483                        com->ac_errno = 0; 
    468484out1: 
    469485                        if (local != NULL) 
     
    473489                        break; 
    474490                } 
    475491                case ADMIN_PROTO_AH: 
    476                 case ADMIN_PROTO_ESP: 
     492                case ADMIN_PROTO_ESP: { 
     493                        struct ph2handle *iph2; 
     494                        struct secpolicy *sp_out = NULL, *sp_in = NULL; 
     495                        struct policyindex spidx; 
     496 
     497                        com->ac_errno = -1; 
     498 
     499                        /* got outbound policy */ 
     500                        memset(&spidx, 0, sizeof(spidx)); 
     501                        spidx.dir = IPSEC_DIR_OUTBOUND; 
     502                        memcpy(&spidx.src, src, sizeof(spidx.src)); 
     503                        memcpy(&spidx.dst, dst, sizeof(spidx.dst)); 
     504                        spidx.prefs = ndx->prefs; 
     505                        spidx.prefd = ndx->prefd; 
     506                        spidx.ul_proto = ndx->ul_proto; 
     507 
     508                        sp_out = getsp_r(&spidx); 
     509                        if (sp_out) { 
     510                                plog(LLV_DEBUG, LOCATION, NULL, 
     511                                        "suitable outbound SP found: %s.\n", 
     512                                        spidx2str(&sp_out->spidx)); 
     513                        } else { 
     514                                com->ac_errno = ENOENT; 
     515                                plog(LLV_NOTIFY, LOCATION, NULL, 
     516                                        "no outbound policy found: %s\n", 
     517                                        spidx2str(&spidx)); 
     518                                break; 
     519                        } 
     520 
     521                        iph2 = getph2byid(src, dst, sp_out->id); 
     522                        if (iph2 != NULL) { 
     523                                event_list = &iph2->evt_listeners; 
     524                                if (iph2->status == PHASE2ST_ESTABLISHED) 
     525                                        com->ac_errno = EEXIST; 
     526                                else 
     527                                        com->ac_errno = 0; 
     528                                break; 
     529                        } 
     530 
     531                        /* get inbound policy */ 
     532                        memset(&spidx, 0, sizeof(spidx)); 
     533                        spidx.dir = IPSEC_DIR_INBOUND; 
     534                        memcpy(&spidx.src, dst, sizeof(spidx.src)); 
     535                        memcpy(&spidx.dst, src, sizeof(spidx.dst)); 
     536                        spidx.prefs = ndx->prefd; 
     537                        spidx.prefd = ndx->prefs; 
     538                        spidx.ul_proto = ndx->ul_proto; 
     539 
     540                        sp_in = getsp_r(&spidx); 
     541                        if (sp_in) { 
     542                                plog(LLV_DEBUG, LOCATION, NULL, 
     543                                        "suitable inbound SP found: %s.\n", 
     544                                        spidx2str(&sp_in->spidx)); 
     545                        } else { 
     546                                com->ac_errno = ENOENT; 
     547                                plog(LLV_NOTIFY, LOCATION, NULL, 
     548                                        "no inbound policy found: %s\n", 
     549                                        spidx2str(&spidx)); 
     550                                break; 
     551                        } 
     552 
     553                        /* allocate a phase 2 */ 
     554                        iph2 = newph2(); 
     555                        if (iph2 == NULL) { 
     556                                plog(LLV_ERROR, LOCATION, NULL, 
     557                                        "failed to allocate phase2 entry.\n"); 
     558                                break; 
     559                        } 
     560                        iph2->side = INITIATOR; 
     561                        iph2->satype = admin2pfkey_proto(com->ac_proto); 
     562                        iph2->spid = sp_out->id; 
     563                        iph2->seq = pk_getseq(); 
     564                        iph2->status = PHASE2ST_STATUS2; 
     565 
     566                        /* set end addresses of SA */ 
     567                        iph2->dst = dupsaddr(dst); 
     568                        iph2->src = dupsaddr(src); 
     569                        if (iph2->dst == NULL || iph2->src == NULL) { 
     570                                delph2(iph2); 
     571                                break; 
     572                        } 
     573 
     574                        if (isakmp_get_sainfo(iph2, sp_out, sp_in) < 0) { 
     575                                delph2(iph2); 
     576                                break; 
     577                        } 
     578 
     579                        insph2(iph2); 
     580                        if (isakmp_post_acquire(iph2) < 0) { 
     581                                unbindph12(iph2); 
     582                                remph2(iph2); 
     583                                delph2(iph2); 
     584                                break; 
     585                        } 
     586 
     587                        event_list = &iph2->evt_listeners; 
     588                        com->ac_errno = 0; 
    477589                        break; 
     590                } 
    478591                default: 
    479592                        /* ignore */ 
    480593                        com->ac_errno = -1; 
     
    491604        if ((error = admin_reply(so2, com, buf)) != 0) 
    492605                goto out; 
    493606 
    494         error = 0; 
     607        if (send_events || event_list != NULL) 
     608                error = evt_subscribe(event_list, so2); 
    495609out: 
    496610        if (buf != NULL) 
    497611                vfree(buf); 
  • src/racoon/evt.c

    old new  
    4646#include "plog.h" 
    4747#include "misc.h" 
    4848#include "admin.h" 
     49#include "handler.h" 
    4950#include "gcmalloc.h" 
    5051#include "evt.h" 
    5152 
    5253#ifdef ENABLE_ADMINPORT 
    53 struct evtlist evtlist = TAILQ_HEAD_INITIALIZER(evtlist); 
    54 int evtlist_len = 0; 
     54static EVT_LISTENER_LIST(evt_listeners); 
     55static EVT_LISTENER_LIST(evt_fds); 
    5556 
    56 void 
    57 evt_push(src, dst, type, optdata) 
    58         struct sockaddr *src; 
    59         struct sockaddr *dst; 
     57struct evtdump { 
     58       struct admin_com adm; 
     59       struct evt_common evt; 
     60}; 
     61 
     62static struct evtdump * 
     63evtdump_create(type, optdata) 
    6064        int type; 
    6165        vchar_t *optdata; 
    6266{ 
    63         struct evtdump *evtdump; 
    64         struct evt *evt; 
     67        struct evtdump *e; 
    6568        size_t len; 
    6669 
    67         /* If admin socket is disabled, silently discard anything */ 
    68         if (adminsock_path == NULL) 
     70        len = sizeof(struct admin_com) + sizeof(struct evt_common); 
     71        if (optdata != NULL) 
     72            len += optdata->l; 
     73 
     74        if ((e = racoon_malloc(len)) == NULL) { 
     75                plog(LLV_ERROR, LOCATION, NULL, "Cannot allocate event: %s\n", 
     76                strerror(errno)); 
     77                return NULL; 
     78        } 
     79 
     80        memset(e, 0, sizeof(struct evtdump)); 
     81        e->adm.ac_len = len; 
     82        e->adm.ac_cmd = ADMIN_SHOW_EVT; 
     83        e->adm.ac_errno = 0; 
     84        e->adm.ac_proto = 0; 
     85        e->evt.ec_type = type; 
     86        time(&e->evt.ec_timestamp); 
     87        if (optdata != NULL) 
     88            memcpy(e + 1, optdata->v, optdata->l); 
     89 
     90        return e; 
     91} 
     92 
     93static void 
     94evt_unsubscribe(l) 
     95        struct evt_listener *l; 
     96{ 
     97        plog(LLV_DEBUG, LOCATION, NULL, 
     98            "[%d] admin connection released\n", l->fd); 
     99 
     100        LIST_REMOVE(l, ll_chain); 
     101        LIST_REMOVE(l, fd_chain); 
     102        close(l->fd); 
     103        racoon_free(l); 
     104} 
     105 
     106static void 
     107evtdump_broadcast(ll, e) 
     108        const struct evt_listener_list *ll; 
     109        struct evtdump *e; 
     110{ 
     111        struct evt_listener *l, *nl; 
     112 
     113        for (l = LIST_FIRST(ll); l != NULL; l = nl) { 
     114                nl = LIST_NEXT(l, ll_chain); 
     115 
     116                if (send(l->fd, e, e->adm.ac_len, 
     117                        MSG_NOSIGNAL | MSG_DONTWAIT) < 0) { 
     118                        plog(LLV_DEBUG, LOCATION, NULL, "Cannot send event to fd: %s\n", 
     119                                strerror(errno)); 
     120                        evt_unsubscribe(l); 
     121                } 
     122 
     123        } 
     124 
     125} 
     126 
     127void 
     128evt_generic(type, optdata) 
     129        int type; 
     130        vchar_t *optdata; 
     131{ 
     132        struct evtdump *e; 
     133 
     134 
     135        if ((e = evtdump_create(type, optdata)) == NULL) 
    69136                return; 
    70137 
    71         /* If we are above the limit, don't record anything */ 
    72         if (evtlist_len > EVTLIST_MAX) { 
    73                 plog(LLV_DEBUG, LOCATION, NULL,  
    74                     "Cannot record event: event queue overflowed\n"); 
     138        evtdump_broadcast(&evt_listeners, e); 
     139 
     140        racoon_free(e); 
     141} 
     142 
     143void 
     144evt_phase1(ph1, type, optdata) 
     145        const struct ph1handle *ph1; 
     146        int type; 
     147        vchar_t *optdata; 
     148{ 
     149        struct evtdump *e; 
     150 
     151        if ((e = evtdump_create(type, optdata)) == NULL) 
     152                return; 
     153                 
     154                        if (ph1->local) 
     155                                memcpy(&e->evt.ec_ph1src, ph1->local, sysdep_sa_len(ph1->local)); 
     156                        if (ph1->remote) 
     157                                memcpy(&e->evt.ec_ph1dst, ph1->remote, sysdep_sa_len(ph1->remote)); 
     158                 
     159                        evtdump_broadcast(&ph1->evt_listeners, e); 
     160                        evtdump_broadcast(&evt_listeners, e); 
     161                 
     162                        racoon_free(e); 
     163                } 
     164 
     165void 
     166evt_phase2(ph2, type, optdata) 
     167        const struct ph2handle *ph2; 
     168        int type; 
     169        vchar_t *optdata; 
     170{ 
     171        struct evtdump *e; 
     172        struct ph1handle *ph1 = ph2->ph1; 
     173 
     174        if ((e = evtdump_create(type, optdata)) == NULL) 
    75175                return; 
     176 
     177        if (ph1) { 
     178                if (ph1->local) 
     179                        memcpy(&e->evt.ec_ph1src, ph1->local, sysdep_sa_len(ph1->local)); 
     180        if (ph1->remote) 
     181                memcpy(&e->evt.ec_ph1dst, ph1->remote, sysdep_sa_len(ph1->remote)); 
    76182        } 
     183        e->evt.ec_ph2msgid = ph2->msgid; 
    77184 
    78         /* If we hit the limit, record an overflow event instead */ 
    79         if (evtlist_len == EVTLIST_MAX) { 
    80                 plog(LLV_ERROR, LOCATION, NULL,  
    81                     "Cannot record event: event queue overflow\n"); 
    82                 src = NULL; 
    83                 dst = NULL; 
    84                 type = EVTT_OVERFLOW; 
    85                 optdata = NULL; 
    86         } 
    87  
    88         len = sizeof(*evtdump); 
    89         if (optdata) 
    90                 len += optdata->l; 
    91  
    92         if ((evtdump = racoon_malloc(len)) == NULL) { 
    93                 plog(LLV_ERROR, LOCATION, NULL, "Cannot record event: %s\n", 
    94                     strerror(errno)); 
    95                 return; 
     185        evtdump_broadcast(&ph2->evt_listeners, e); 
     186        if (ph1) 
     187                evtdump_broadcast(&ph1->evt_listeners, e); 
     188                evtdump_broadcast(&evt_listeners, e); 
     189 
     190                racoon_free(e); 
    96191        } 
    97192 
    98         if ((evt = racoon_malloc(sizeof(*evt))) == NULL) { 
    99                 plog(LLV_ERROR, LOCATION, NULL, "Cannot record event: %s\n", 
    100                     strerror(errno)); 
    101                 racoon_free(evtdump); 
    102                 return; 
     193int 
     194evt_subscribe(list, fd) 
     195        struct evt_listener_list *list; 
     196        int fd; 
     197{ 
     198        struct evt_listener *l; 
     199 
     200        if ((l = racoon_malloc(sizeof(*l))) == NULL) { 
     201                plog(LLV_ERROR, LOCATION, NULL, 
     202                        "Cannot allocate event listener: %s\n", 
     203                        strerror(errno)); 
     204            return errno; 
    103205        } 
    104206 
    105         if (src) 
    106                 memcpy(&evtdump->src, src, sysdep_sa_len(src)); 
    107         if (dst) 
    108                 memcpy(&evtdump->dst, dst, sysdep_sa_len(dst)); 
    109         evtdump->len = len; 
    110         evtdump->type = type; 
    111         time(&evtdump->timestamp); 
     207        if (list == NULL) 
     208                list = &evt_listeners; 
    112209 
    113         if (optdata) 
    114                 memcpy(evtdump + 1, optdata->v, optdata->l); 
     210        LIST_INSERT_HEAD(list, l, ll_chain); 
     211        LIST_INSERT_HEAD(&evt_fds, l, fd_chain); 
     212        l->fd = fd; 
    115213 
    116         evt->dump = evtdump; 
    117         TAILQ_INSERT_TAIL(&evtlist, evt, next); 
     214        plog(LLV_DEBUG, LOCATION, NULL, 
     215                "[%d] admin connection is polling events\n", fd); 
    118216 
    119         evtlist_len++; 
     217        return -2; 
     218} 
    120219 
    121         return; 
     220void 
     221evt_list_init(list) 
     222        struct evt_listener_list *list; 
     223{ 
     224        LIST_INIT(list); 
    122225} 
    123226 
    124 struct evtdump * 
    125 evt_pop(void) { 
    126         struct evtdump *evtdump; 
    127         struct evt *evt; 
    128227 
    129         if ((evt = TAILQ_FIRST(&evtlist)) == NULL) 
    130                 return NULL; 
     228void 
     229evt_list_cleanup(list) 
     230        struct evt_listener_list *list; 
     231{ 
     232        while (!LIST_EMPTY(list)) 
     233                evt_unsubscribe(LIST_FIRST(list)); 
     234} 
    131235 
    132         evtdump = evt->dump; 
    133         TAILQ_REMOVE(&evtlist, evt, next); 
    134         racoon_free(evt); 
    135         evtlist_len--; 
    136  
    137         return evtdump; 
    138 } 
    139  
    140 vchar_t * 
    141 evt_dump(void) { 
    142         struct evtdump *evtdump; 
    143         vchar_t *buf = NULL; 
    144  
    145         if ((evtdump = evt_pop()) != NULL) { 
    146                 if ((buf = vmalloc(evtdump->len)) == NULL) { 
    147                         plog(LLV_ERROR, LOCATION, NULL,  
    148                             "evt_dump failed: %s\n", strerror(errno)); 
    149                         return NULL; 
    150                 } 
    151                 memcpy(buf->v, evtdump, evtdump->len);   
    152                 racoon_free(evtdump); 
     236int 
     237evt_get_fdmask(nfds, fdset) 
     238        int nfds; 
     239        fd_set *fdset; 
     240{ 
     241        struct evt_listener *l; 
     242        LIST_FOREACH(l, &evt_fds, fd_chain) { 
     243                FD_SET(l->fd, fdset); 
     244                if (l->fd + 1 > nfds) 
     245                        nfds = l->fd + 1; 
    153246        } 
     247        return nfds; 
     248} 
    154249 
    155         return buf; 
     250void 
     251evt_handle_fdmask(fdset) 
     252        fd_set *fdset; 
     253{ 
     254        struct evt_listener *l, *nl; 
     255 
     256        for (l = LIST_FIRST(&evt_fds); l != NULL; l = nl) { 
     257        nl = LIST_NEXT(l, ll_chain); 
     258 
     259                if (FD_ISSET(l->fd, fdset)) 
     260                        evt_unsubscribe(l); 
     261        } 
    156262} 
    157263 
    158264#endif /* ENABLE_ADMINPORT */ 
  • src/racoon/evt.h

    old new  
    3434#ifndef _EVT_H 
    3535#define _EVT_H 
    3636 
    37 struct evtdump { 
    38         size_t len;      
    39         struct sockaddr_storage src; 
    40         struct sockaddr_storage dst; 
    41         time_t timestamp; 
    42         int type; 
     37#ifdef ENABLE_ADMINPORT 
     38 
     39struct evt_listener { 
     40       LIST_ENTRY(evt_listener) ll_chain; 
     41       LIST_ENTRY(evt_listener) fd_chain; 
     42       int fd; 
     43}; 
     44LIST_HEAD(evt_listener_list, evt_listener); 
     45#define EVT_LISTENER_LIST(x) struct evt_listener_list x; 
     46 
     47struct ph1handle; 
     48struct ph2handle; 
     49 
     50struct evt_common { 
     51        uint32_t ec_type; 
     52        time_t ec_timestamp; 
     53 
     54        struct sockaddr_storage ec_ph1src; 
     55        struct sockaddr_storage ec_ph1dst; 
     56        u_int32_t ec_ph2msgid; 
     57 
    4358        /*  
    4459         * Optionnal list of struct isakmp_data  
    4560         * for type EVTT_ISAKMP_CFG_DONE 
     
    4762}; 
    4863 
    4964/* type */ 
    50 #define EVTT_UNSEPC             0 
    51 #define EVTT_PHASE1_UP          1 
    52 #define EVTT_PHASE1_DOWN        2 
    53 #define EVTT_XAUTH_SUCCESS      3 
    54 #define EVTT_ISAKMP_CFG_DONE    4 
    55 #define EVTT_PHASE2_UP          5 
    56 #define EVTT_PHASE2_DOWN        6 
    57 #define EVTT_DPD_TIMEOUT        7 
    58 #define EVTT_PEER_NO_RESPONSE   8 
    59 #define EVTT_PEER_DELETE        9 
    60 #define EVTT_RACOON_QUIT        10 
    61 #define EVTT_XAUTH_FAILED       11 
    62 #define EVTT_OVERFLOW           12      /* Event queue overflowed */ 
    63 #define EVTT_PEERPH1AUTH_FAILED 13 
    64 #define EVTT_PEERPH1_NOPROP     14      /* NO_PROPOSAL_CHOSEN & friends */ 
    65 #define EVTT_NO_ISAKMP_CFG      15      /* no need to wait for mode_cfg */ 
    66  
    67 struct evt { 
    68         struct evtdump *dump; 
    69         TAILQ_ENTRY(evt) next; 
    70 }; 
    71  
    72 TAILQ_HEAD(evtlist, evt); 
    73  
    74 #define EVTLIST_MAX     32 
     65#define EVTT_RACOON_QUIT               0x0001 
     66#define EVTT_PHASE1_UP                 0x0100 
     67#define EVTT_PHASE1_DOWN               0x0101 
     68#define EVTT_PHASE1_NO_RESPONSE                0x0102 
     69#define EVTT_PHASE1_NO_PROPOSAL                0x0103 
     70#define EVTT_PHASE1_AUTH_FAILED                0x0104 
     71#define EVTT_PHASE1_DPD_TIMEOUT                0x0105 
     72#define EVTT_PHASE1_PEER_DELETED       0x0106 
     73#define EVTT_PHASE1_MODE_CFG           0x0107 
     74#define EVTT_PHASE1_XAUTH_SUCCESS      0x0108 
     75#define EVTT_PHASE1_XAUTH_FAILED       0x0109 
     76 
     77#define EVTT_PHASE2_NO_PHASE1          0x0200 
     78#define EVTT_PHASE2_UP                 0x0201 
     79#define EVTT_PHASE2_DOWN               0x0202 
     80#define EVTT_PHASE2_NO_RESPONSE                0x0203 
     81 
     82void evt_generic __P((int type, vchar_t *optdata)); 
     83void evt_phase1 __P((const struct ph1handle *ph1, int type, vchar_t *optdata)); 
     84void evt_phase2 __P((const struct ph2handle *ph2, int type, vchar_t *optdata)); 
     85 
     86int  evt_subscribe __P((struct evt_listener_list *list, int fd)); 
     87void evt_list_init __P((struct evt_listener_list *list)); 
     88void evt_list_cleanup __P((struct evt_listener_list *list)); 
     89int  evt_get_fdmask __P((int nfds, fd_set *fdset)); 
     90void evt_handle_fdmask __P((fd_set *fdset)); 
     91  
     92#else 
    7593 
    76 #ifdef ENABLE_ADMINPORT 
    77 struct evtdump *evt_pop(void); 
    78 vchar_t *evt_dump(void); 
    79 void evt_push(struct sockaddr *, struct sockaddr *, int, vchar_t *); 
    80 #endif 
     94#define EVT_LISTENER_LIST(x) 
     95#define evt_generic(type, optdata) ; 
     96#define evt_phase1(ph1, type, optdata) ; 
     97#define evt_phase2(ph2, type, optdata) ; 
     98 
     99#define evt_subscribe(eventlist, fd) ; 
     100#define evt_list_init(eventlist) ; 
     101#define evt_list_cleanup(eventlist) ; 
     102#define evt_get_fdmask(nfds, fdset) nfds 
     103#define evt_handle_fdmask(fdset) ; 
    81104 
    82 #ifdef ENABLE_ADMINPORT 
    83 #define EVT_PUSH(src, dst, type, optdata) evt_push(src, dst, type, optdata); 
    84 #else 
    85 #define EVT_PUSH(src, dst, type, optdata) ; 
    86 #endif 
     105#endif /* ENABLE_ADMINPORT */ 
    87106 
    88107#endif /* _EVT_H */ 
  • src/racoon/handler.c

    old new  
    289289 
    290290        /* SA down shell script hook */ 
    291291        script_hook(iph1, SCRIPT_PHASE1_DOWN); 
    292  
    293         EVT_PUSH(iph1->local, iph1->remote, EVTT_PHASE1_DOWN, NULL); 
     292        evt_list_cleanup(&iph1->evt_listeners); 
    294293 
    295294#ifdef ENABLE_NATT 
    296295        if (iph1->natt_flags & NAT_KA_QUEUED) 
  • src/racoon/handler.h

    old new  
    4141 
    4242#include "isakmp_var.h" 
    4343#include "oakley.h" 
     44#include "evt.h" 
    4445 
    4546/* Phase 1 handler */ 
    4647/* 
     
    211212#ifdef ENABLE_HYBRID 
    212213        struct isakmp_cfg_state *mode_cfg;      /* ISAKMP mode config state */ 
    213214#endif        
    214  
     215        EVT_LISTENER_LIST(evt_listeners); 
    215216}; 
    216217 
    217218/* Phase 2 handler */ 
     
    320321 
    321322        LIST_ENTRY(ph2handle) chain; 
    322323        LIST_ENTRY(ph2handle) ph1bind;  /* chain to ph1handle */ 
     324        EVT_LISTENER_LIST(evt_listeners); 
    323325}; 
    324326 
    325327/* 
  • src/racoon/isakmp_agg.c

    old new  
    587587                        /* message printed inner oakley_validate_auth() */ 
    588588                        goto end; 
    589589                } 
    590                 EVT_PUSH(iph1->local, iph1->remote,  
    591                     EVTT_PEERPH1AUTH_FAILED, NULL); 
     590                evt_phase1(iph1, EVTT_PHASE1_AUTH_FAILED, NULL); 
    592591                isakmp_info_send_n1(iph1, ptype, NULL); 
    593592                goto end; 
    594593        } 
     
    14861485                        /* message printed inner oakley_validate_auth() */ 
    14871486                        goto end; 
    14881487                } 
    1489                 EVT_PUSH(iph1->local, iph1->remote,  
    1490                     EVTT_PEERPH1AUTH_FAILED, NULL); 
     1488                evt_phase1(iph1, EVTT_PHASE1_AUTH_FAILED, NULL); 
    14911489                isakmp_info_send_n1(iph1, ptype, NULL); 
    14921490                goto end; 
    14931491        } 
  • src/racoon/isakmp_base.c

    old new  
    716716                        /* message printed inner oakley_validate_auth() */ 
    717717                        goto end; 
    718718                } 
    719                 EVT_PUSH(iph1->local, iph1->remote,  
    720                     EVTT_PEERPH1AUTH_FAILED, NULL); 
     719                evt_phase1(iph1, EVTT_PHASE1_AUTH_FAILED, NULL); 
    721720                isakmp_info_send_n1(iph1, ptype, NULL); 
    722721                goto end; 
    723722        } 
     
    12421241                        /* message printed inner oakley_validate_auth() */ 
    12431242                        goto end; 
    12441243                } 
    1245                 EVT_PUSH(iph1->local, iph1->remote,  
    1246                     EVTT_PEERPH1AUTH_FAILED, NULL); 
     1244                evt_phase1(iph1, EVTT_PHASE1_AUTH_FAILED, NULL); 
    12471245                isakmp_info_send_n1(iph1, ptype, NULL); 
    12481246                goto end; 
    12491247        } 
  • src/racoon/isakmp.c

    old new  
    8888#include "pfkey.h" 
    8989#include "crypto_openssl.h" 
    9090#include "policy.h" 
     91#include "algorithm.h" 
     92#include "proposal.h" 
     93#include "sainfo.h" 
    9194#include "isakmp_ident.h" 
    9295#include "isakmp_agg.h" 
    9396#include "isakmp_base.h" 
     
    10151018} 
    10161019 
    10171020/* new negotiation of phase 1 for initiator */ 
    1018 int 
     1021struct ph1handle * 
    10191022isakmp_ph1begin_i(rmconf, remote, local) 
    10201023        struct remoteconf *rmconf; 
    10211024        struct sockaddr *remote, *local; 
     
    10281031        /* get new entry to isakmp status table. */ 
    10291032        iph1 = newph1(); 
    10301033        if (iph1 == NULL) 
    1031                 return -1; 
     1034                return NULL; 
    10321035 
    10331036        iph1->status = PHASE1ST_START; 
    10341037        iph1->rmconf = rmconf; 
     
    10431046#ifdef ENABLE_HYBRID 
    10441047        if ((iph1->mode_cfg = isakmp_cfg_mkstate()) == NULL) { 
    10451048                delph1(iph1); 
    1046                 return -1; 
     1049                return NULL; 
    10471050        } 
    10481051#endif 
    10491052#ifdef ENABLE_FRAG 
     
    10591062        /* XXX copy remote address */ 
    10601063        if (copy_ph1addresses(iph1, rmconf, remote, local) < 0) { 
    10611064                delph1(iph1); 
    1062                 return -1; 
     1065                return NULL; 
    10631066        } 
    10641067 
    10651068        (void)insph1(iph1); 
     
    10951098                remph1(iph1); 
    10961099                delph1(iph1); 
    10971100 
    1098                 return -1; 
     1101                return NULL; 
    10991102        } 
    11001103 
    11011104#ifdef ENABLE_STATS 
     
    11061109                timedelta(&start, &end)); 
    11071110#endif 
    11081111 
    1109         return 0; 
     1112        return iph1; 
    11101113} 
    11111114 
    11121115/* new negotiation of phase 1 for responder */ 
     
    18871890                plog(LLV_ERROR, LOCATION, NULL, 
    18881891                        "phase1 negotiation failed due to time up. %s\n", 
    18891892                        isakmp_pindex(&iph1->index, iph1->msgid)); 
    1890                 EVT_PUSH(iph1->local, iph1->remote,  
    1891                     EVTT_PEER_NO_RESPONSE, NULL); 
     1893                evt_phase1(iph1, EVTT_PHASE1_NO_RESPONSE, NULL); 
    18921894 
    18931895                return -1; 
    18941896        } 
     
    18971899                plog(LLV_ERROR, LOCATION, NULL, 
    18981900                         "phase1 negotiation failed due to send error. %s\n", 
    18991901                         isakmp_pindex(&iph1->index, iph1->msgid)); 
    1900                 EVT_PUSH(iph1->local, iph1->remote,  
    1901                                  EVTT_PEER_NO_RESPONSE, NULL); 
     1902                evt_phase1(iph1, EVTT_PHASE1_NO_RESPONSE, NULL); 
    19021903                return -1; 
    19031904        } 
    19041905 
     
    19471948                plog(LLV_ERROR, LOCATION, NULL, 
    19481949                        "phase2 negotiation failed due to time up. %s\n", 
    19491950                                isakmp_pindex(&iph2->ph1->index, iph2->msgid)); 
    1950                 EVT_PUSH(iph2->src, iph2->dst, EVTT_PEER_NO_RESPONSE, NULL); 
     1951                evt_phase2(iph2, EVTT_PHASE2_NO_RESPONSE, NULL); 
    19511952                unbindph12(iph2); 
    19521953                return -1; 
    19531954        } 
     
    19561957                plog(LLV_ERROR, LOCATION, NULL, 
    19571958                        "phase2 negotiation failed due to send error. %s\n", 
    19581959                                isakmp_pindex(&iph2->ph1->index, iph2->msgid)); 
    1959                 EVT_PUSH(iph2->src, iph2->dst, EVTT_PEER_NO_RESPONSE, NULL); 
    1960  
     1960                evt_phase2(iph2, EVTT_PHASE2_NO_RESPONSE, NULL); 
    19611961                return -1; 
    19621962        } 
    19631963 
     
    20482048        plog(LLV_INFO, LOCATION, NULL, 
    20492049                "ISAKMP-SA deleted %s-%s spi:%s\n", 
    20502050                src, dst, isakmp_pindex(&iph1->index, 0)); 
    2051         EVT_PUSH(iph1->local, iph1->remote, EVTT_PHASE1_DOWN, NULL); 
     2051        evt_phase1(iph1, EVTT_PHASE1_DOWN, NULL); 
    20522052        racoon_free(src); 
    20532053        racoon_free(dst); 
    20542054 
     
    21952195                        saddrwop2str(iph2->dst)); 
    21962196 
    21972197                /* start phase 1 negotiation as a initiator. */ 
    2198                 if (isakmp_ph1begin_i(rmconf, iph2->dst, iph2->src) < 0) { 
     2198                if (isakmp_ph1begin_i(rmconf, iph2->dst, iph2->src) == NULL) { 
    21992199                        SCHED_KILL(sc); 
    22002200                        return -1; 
    22012201                } 
     
    22282228        return 0; 
    22292229} 
    22302230 
     2231int 
     2232isakmp_get_sainfo(iph2, sp_out, sp_in) 
     2233        struct ph2handle *iph2; 
     2234        struct secpolicy *sp_out, *sp_in; 
     2235{ 
     2236        int remoteid=0; 
     2237 
     2238        plog(LLV_DEBUG, LOCATION, NULL, 
     2239                "new acquire %s\n", spidx2str(&sp_out->spidx)); 
     2240 
     2241        /* get sainfo */ 
     2242        { 
     2243                vchar_t *idsrc, *iddst; 
     2244 
     2245                idsrc = ipsecdoi_sockaddr2id((struct sockaddr *)&sp_out->spidx.src, 
     2246                        sp_out->spidx.prefs, sp_out->spidx.ul_proto); 
     2247                if (idsrc == NULL) { 
     2248                        plog(LLV_ERROR, LOCATION, NULL, 
     2249                                "failed to get ID for %s\n", 
     2250                                spidx2str(&sp_out->spidx)); 
     2251                        return -1; 
     2252                } 
     2253                iddst = ipsecdoi_sockaddr2id((struct sockaddr *)&sp_out->spidx.dst, 
     2254                        sp_out->spidx.prefd, sp_out->spidx.ul_proto); 
     2255                if (iddst == NULL) { 
     2256                        plog(LLV_ERROR, LOCATION, NULL, 
     2257                                "failed to get ID for %s\n", 
     2258                                spidx2str(&sp_out->spidx)); 
     2259                        vfree(idsrc); 
     2260                        return -1; 
     2261                } 
     2262                { 
     2263                        struct remoteconf *conf; 
     2264                        conf = getrmconf(iph2->dst); 
     2265                        if (conf != NULL) 
     2266                                remoteid=conf->ph1id; 
     2267                        else{ 
     2268                                plog(LLV_DEBUG, LOCATION, NULL, "Warning: no valid rmconf !\n"); 
     2269                                remoteid=0; 
     2270                        } 
     2271                } 
     2272                iph2->sainfo = getsainfo(idsrc, iddst, NULL, remoteid); 
     2273                vfree(idsrc); 
     2274                vfree(iddst); 
     2275                if (iph2->sainfo == NULL) { 
     2276                        plog(LLV_ERROR, LOCATION, NULL, 
     2277                                "failed to get sainfo.\n"); 
     2278                        return -1; 
     2279                        /* XXX should use the algorithm list from register message */ 
     2280                } 
     2281 
     2282                plog(LLV_DEBUG, LOCATION, NULL, 
     2283                        "selected sainfo: %s\n", sainfo2str(iph2->sainfo)); 
     2284        } 
     2285 
     2286        if (set_proposal_from_policy(iph2, sp_out, sp_in) < 0) { 
     2287                plog(LLV_ERROR, LOCATION, NULL, 
     2288                        "failed to create saprop.\n"); 
     2289                return -1; 
     2290        } 
     2291 
     2292        return 0; 
     2293} 
     2294 
     2295 
    22312296/* 
    22322297 * receive GETSPI from kernel. 
    22332298 */ 
     
    29312996                src, dst, 
    29322997                isakmp_pindex(&iph1->index, 0)); 
    29332998         
    2934         EVT_PUSH(iph1->local, iph1->remote, EVTT_PHASE1_UP, NULL); 
     2999        evt_phase1(iph1, EVTT_PHASE1_UP, NULL); 
    29353000        if(!iph1->rmconf->mode_cfg) 
    2936                 EVT_PUSH(iph1->local, iph1->remote, EVTT_NO_ISAKMP_CFG, NULL); 
     3001                evt_phase1(iph1, EVTT_PHASE1_MODE_CFG, NULL); 
    29373002 
    29383003        racoon_free(src); 
    29393004        racoon_free(dst); 
  • src/racoon/isakmp_cfg.c

    old new  
    473473                            "Cannot allocate memory: %s\n", strerror(errno)); 
    474474                } else { 
    475475                        memcpy(buf->v, attrpl + 1, buf->l); 
    476                         EVT_PUSH(iph1->local, iph1->remote,  
    477                             EVTT_ISAKMP_CFG_DONE, buf); 
     476                        evt_phase1(iph1, EVTT_PHASE1_MODE_CFG, buf); 
    478477                        vfree(buf); 
    479478                } 
    480479        } 
  • src/racoon/isakmp_ident.c

    old new  
    788788                                /* msg printed inner oakley_validate_auth() */ 
    789789                                goto end; 
    790790                        } 
    791                         EVT_PUSH(iph1->local, iph1->remote,  
    792                             EVTT_PEERPH1AUTH_FAILED, NULL); 
     791                        evt_phase1(iph1, EVTT_PHASE1_AUTH_FAILED, NULL); 
    793792                        isakmp_info_send_n1(iph1, type, NULL); 
    794793                        goto end; 
    795794                } 
     
    15371536                                /* msg printed inner oakley_validate_auth() */ 
    15381537                                goto end; 
    15391538                        } 
    1540                         EVT_PUSH(iph1->local, iph1->remote,  
    1541                             EVTT_PEERPH1AUTH_FAILED, NULL); 
     1539                        evt_phase1(iph1, EVTT_PHASE1_AUTH_FAILED, NULL); 
    15421540                        isakmp_info_send_n1(iph1, type, NULL); 
    15431541                        goto end; 
    15441542                } 
  • src/racoon/isakmp_inf.c

    old new  
    510510                del_ph1=getph1byindex((isakmp_index *)(delete + 1)); 
    511511                if(del_ph1 != NULL){ 
    512512 
    513                         EVT_PUSH(del_ph1->local, del_ph1->remote, 
    514                         EVTT_PEERPH1_NOPROP, NULL); 
     513                        evt_phase1(iph1, EVTT_PHASE1_PEER_DELETED, NULL); 
    515514                        if (del_ph1->scr) 
    516515                                SCHED_KILL(del_ph1->scr); 
    517516 
     
    532531                                delete->spi_size, delete->proto_id); 
    533532                        return 0; 
    534533                } 
    535                 EVT_PUSH(iph1->local, iph1->remote,  
    536                     EVTT_PEER_DELETE, NULL); 
    537534                purge_ipsec_spi(iph1->remote, delete->proto_id, 
    538535                    (u_int32_t *)(delete + 1), num_spi); 
    539536                break; 
     
    16301627                        "DPD: remote (ISAKMP-SA spi=%s) seems to be dead.\n", 
    16311628                        isakmp_pindex(&iph1->index, 0)); 
    16321629 
    1633                 EVT_PUSH(iph1->local, iph1->remote, EVTT_DPD_TIMEOUT, NULL); 
     1630                evt_phase1(iph1, EVTT_PHASE1_DPD_TIMEOUT, NULL); 
    16341631                purge_remote(iph1); 
    16351632 
    16361633                /* Do not reschedule here: phase1 is deleted, 
  • src/racoon/isakmp_var.h

    old new  
    3535#define _ISAKMP_VAR_H 
    3636 
    3737#include "vmbuf.h" 
     38#include "policy.h" 
    3839 
    3940#define PORT_ISAKMP 500 
    4041#define PORT_ISAKMP_NATT 4500 
     
    6263struct isakmp_pl_nonce; /* XXX */ 
    6364 
    6465extern int isakmp_handler __P((int)); 
    65 extern int isakmp_ph1begin_i __P((struct remoteconf *, struct sockaddr *, 
    66         struct sockaddr *)); 
     66extern struct ph1handle *isakmp_ph1begin_i __P((struct remoteconf *, 
     67        struct sockaddr *, struct sockaddr *)); 
    6768 
    6869extern vchar_t *isakmp_parsewoh __P((int, struct isakmp_gen *, int)); 
    6970extern vchar_t *isakmp_parse __P((vchar_t *)); 
     
    8788extern void isakmp_ph2delete_stub __P((void *)); 
    8889extern void isakmp_ph2delete __P((struct ph2handle *)); 
    8990 
     91extern int isakmp_get_sainfo __P((struct ph2handle *, struct secpolicy *, struct secpolicy *)); 
    9092extern int isakmp_post_acquire __P((struct ph2handle *)); 
    9193extern int isakmp_post_getspi __P((struct ph2handle *)); 
    9294extern void isakmp_chkph1there_stub __P((void *)); 
  • src/racoon/isakmp_xauth.c

    old new  
    15681568                        plog(LLV_ERROR, LOCATION, NULL,  
    15691569                            "Xauth authentication failed\n"); 
    15701570 
    1571                         EVT_PUSH(iph1->local, iph1->remote,  
    1572                             EVTT_XAUTH_FAILED, NULL); 
     1571                        evt_phase1(iph1, EVTT_PHASE1_XAUTH_FAILED, NULL); 
    15731572 
    15741573                        iph1->mode_cfg->flags |= ISAKMP_CFG_DELETE_PH1; 
    15751574                } else { 
    1576                         EVT_PUSH(iph1->local, iph1->remote,  
    1577                             EVTT_XAUTH_SUCCESS, NULL); 
     1575                        evt_phase1(iph1, EVTT_PHASE1_XAUTH_SUCCESS, NULL); 
    15781576                } 
    15791577 
    15801578 
  • src/racoon/pfkey.c

    old new  
    9292#include "algorithm.h" 
    9393#include "sainfo.h" 
    9494#include "admin.h" 
     95#include "evt.h" 
    9596#include "privsep.h" 
    9697#include "strnames.h" 
    9798#include "backupsa.h" 
     
    12661267         
    12671268        /* update status */ 
    12681269        iph2->status = PHASE2ST_ESTABLISHED; 
     1270        evt_phase2(iph2, EVTT_PHASE2_UP, NULL); 
    12691271 
    12701272#ifdef ENABLE_STATS 
    12711273        gettimeofday(&iph2->end, NULL); 
     
    16361638        struct ph2handle *iph2[MAXNESTEDSA]; 
    16371639        struct sockaddr *src, *dst; 
    16381640        int n;  /* # of phase 2 handler */ 
    1639         int remoteid=0; 
    16401641#ifdef HAVE_SECCTX 
    16411642        struct sadb_x_sec_ctx *m_sec_ctx; 
    16421643#endif /* HAVE_SECCTX */ 
     
    18251826                return -1; 
    18261827        } 
    18271828 
    1828         plog(LLV_DEBUG, LOCATION, NULL, 
    1829                 "new acquire %s\n", spidx2str(&sp_out->spidx)); 
    1830  
    1831         /* get sainfo */ 
    1832     { 
    1833         vchar_t *idsrc, *iddst; 
    1834  
    1835         idsrc = ipsecdoi_sockaddr2id((struct sockaddr *)&sp_out->spidx.src, 
    1836                                 sp_out->spidx.prefs, sp_out->spidx.ul_proto); 
    1837         if (idsrc == NULL) { 
    1838                 plog(LLV_ERROR, LOCATION, NULL, 
    1839                         "failed to get ID for %s\n", 
    1840                         spidx2str(&sp_out->spidx)); 
    1841                 delph2(iph2[n]); 
    1842                 return -1; 
    1843         } 
    1844         iddst = ipsecdoi_sockaddr2id((struct sockaddr *)&sp_out->spidx.dst, 
    1845                                 sp_out->spidx.prefd, sp_out->spidx.ul_proto); 
    1846         if (iddst == NULL) { 
    1847                 plog(LLV_ERROR, LOCATION, NULL, 
    1848                         "failed to get ID for %s\n", 
    1849                         spidx2str(&sp_out->spidx)); 
    1850                 vfree(idsrc); 
    1851                 delph2(iph2[n]); 
    1852                 return -1; 
    1853         } 
    1854         { 
    1855                 struct remoteconf *conf; 
    1856                 conf = getrmconf(iph2[n]->dst); 
    1857                 if (conf != NULL) 
    1858                         remoteid=conf->ph1id; 
    1859                 else{ 
    1860                         plog(LLV_DEBUG, LOCATION, NULL, "Warning: no valid rmconf !\n"); 
    1861                         remoteid=0; 
    1862                 } 
    1863         } 
    1864         iph2[n]->sainfo = getsainfo(idsrc, iddst, NULL, remoteid); 
    1865         vfree(idsrc); 
    1866         vfree(iddst); 
    1867         if (iph2[n]->sainfo == NULL) { 
    1868                 plog(LLV_ERROR, LOCATION, NULL, 
    1869                         "failed to get sainfo.\n"); 
     1829        if (isakmp_get_sainfo(iph2[n], sp_out, sp_in) < 0) { 
    18701830                delph2(iph2[n]); 
    18711831                return -1; 
    1872                 /* XXX should use the algorithm list from register message */ 
    18731832        } 
    18741833 
    1875         plog(LLV_DEBUG, LOCATION, NULL, 
    1876                 "selected sainfo: %s\n", sainfo2str(iph2[n]->sainfo)); 
    1877     } 
    1878  
    1879         if (set_proposal_from_policy(iph2[n], sp_out, sp_in) < 0) { 
    1880                 plog(LLV_ERROR, LOCATION, NULL, 
    1881                         "failed to create saprop.\n"); 
    1882                 delph2(iph2[n]); 
    1883                 return -1; 
    1884         } 
    18851834#ifdef HAVE_SECCTX 
    18861835        if (m_sec_ctx) { 
    18871836                set_secctx_in_proposal(iph2[n], spidx); 
  • src/racoon/racoonctl.c

    old new  
    135135struct evtmsg { 
    136136        int type; 
    137137        char *msg; 
    138         enum { UNSPEC, ERROR, INFO } level; 
    139138} evtmsg[] = { 
    140         { EVTT_PHASE1_UP, "Phase 1 established", INFO }, 
    141         { EVTT_PHASE1_DOWN, "Phase 1 deleted", INFO }, 
    142         { EVTT_XAUTH_SUCCESS, "Xauth exchange passed", INFO }, 
    143         { EVTT_ISAKMP_CFG_DONE, "ISAKMP mode config done", INFO }, 
    144         { EVTT_PHASE2_UP, "Phase 2 established", INFO }, 
    145         { EVTT_PHASE2_DOWN, "Phase 2 deleted", INFO }, 
    146         { EVTT_DPD_TIMEOUT, "Peer not reachable anymore", ERROR }, 
    147         { EVTT_PEER_NO_RESPONSE, "Peer not responding", ERROR }, 
    148         { EVTT_PEER_DELETE, "Peer terminated security association", ERROR }, 
    149         { EVTT_RACOON_QUIT, "Raccon terminated", ERROR }, 
    150         { EVTT_OVERFLOW, "Event queue overflow", ERROR }, 
    151         { EVTT_XAUTH_FAILED, "Xauth exchange failed", ERROR }, 
    152         { EVTT_PEERPH1AUTH_FAILED, "Peer failed phase 1 authentication " 
    153             "(certificate problem?)", ERROR }, 
    154         { EVTT_PEERPH1_NOPROP, "Peer failed phase 1 initiation " 
    155             "(proposal problem?)", ERROR }, 
    156         { 0, NULL, UNSPEC }, 
    157         { EVTT_NO_ISAKMP_CFG, "No need for ISAKMP mode config ", INFO }, 
     139        { EVTT_RACOON_QUIT,             "Racoon terminated" }, 
     140 
     141        { EVTT_PHASE1_UP,               "Phase 1 established" }, 
     142        { EVTT_PHASE1_DOWN,             "Phase 1 deleted" }, 
     143        { EVTT_PHASE1_NO_RESPONSE,      "Phase 1 error: peer not responding" }, 
     144        { EVTT_PHASE1_NO_PROPOSAL,      "Phase 1 error: no proposal chosen" }, 
     145        { EVTT_PHASE1_AUTH_FAILED, 
     146          "Phase 1 error: authentication failed (bad certificate?)" }, 
     147        { EVTT_PHASE1_DPD_TIMEOUT,      "Phase 1 error: dead peer detected" }, 
     148        { EVTT_PHASE1_MODE_CFG,         "Phase 1 mode configuration done" }, 
     149        { EVTT_PHASE1_XAUTH_SUCCESS,    "Phase 1 Xauth succeeded" }, 
     150        { EVTT_PHASE1_XAUTH_FAILED,     "Phase 1 Xauth failed" }, 
     151 
     152        { EVTT_PHASE2_NO_PHASE1,        "Phase 2 error: no suitable phase 1" }, 
     153        { EVTT_PHASE2_UP,               "Phase 2 established" }, 
     154        { EVTT_PHASE2_DOWN,             "Phase 2 deleted" }, 
     155        { EVTT_PHASE2_NO_RESPONSE,      "Phase 2 error: no response" }, 
    158156}; 
    159157 
    160158static int get_proto __P((char *)); 
     
    184182        { IPPROTO_ICMP, "icmp" }, 
    185183        { IPPROTO_TCP,  "tcp" }, 
    186184        { IPPROTO_UDP,  "udp" }, 
     185        { IPPROTO_GRE,  "gre" }, 
    187186        { 0, NULL }, 
    188187}; 
    189188 
     
    193192 
    194193char *pname; 
    195194int long_format = 0; 
    196  
    197 #define EVTF_NONE               0x0000  /* Ignore any events */ 
    198 #define EVTF_LOOP               0x0001  /* Loop awaiting for new events */ 
    199 #define EVTF_CFG_STOP           0x0002  /* Stop after ISAKMP mode config */ 
    200 #define EVTF_CFG                0x0004  /* Print ISAKMP mode config info */ 
    201 #define EVTF_ALL                0x0008  /* Print any events */ 
    202 #define EVTF_PURGE              0x0010  /* Print all available events */ 
    203 #define EVTF_PH1DOWN_STOP       0x0020  /* Stop when phase 1 SA gets down */ 
    204 #define EVTF_PH1DOWN            0x0040  /* Print that phase 1 SA got down */ 
    205 #define EVTF_ERR                0x0080  /* Print any error */ 
    206 #define EVTF_ERR_STOP           0x0100  /* Stop on any error */ 
    207  
    208 int evt_filter = EVTF_NONE; 
    209 time_t evt_start; 
     195int evt_quit_event = 0; 
    210196 
    211197void dump_isakmp_sa __P((char *, int)); 
    212198void dump_internal __P((char *, int)); 
    213199char *pindex_isakmp __P((isakmp_index *)); 
    214200void print_schedule __P((caddr_t, int)); 
    215 void print_evt __P((caddr_t, int)); 
    216 void print_cfg __P((caddr_t, int)); 
    217 void print_err __P((caddr_t, int)); 
    218 void print_ph1down __P((caddr_t, int)); 
    219 void print_ph1up __P((caddr_t, int)); 
    220 int evt_poll __P((void)); 
     201void print_evt __P((struct evt_common *)); 
    221202char * fixed_addr __P((char *, char *, int)); 
    222203 
    223204static void 
     
    226207        printf( 
    227208"Usage:\n" 
    228209"  %s reload-config\n" 
     210"  %s show-schedule\n" 
    229211"  %s [-l [-l]] show-sa [protocol]\n" 
    230212"  %s flush-sa [protocol]\n" 
    231213"  %s delete-sa <saopts>\n" 
    232 "  %s establish-sa [-u identity] <saopts>\n" 
     214"  %s establish-sa [-u identity] [-w] <saopts>\n" 
    233215"  %s vpn-connect [-u identity] vpn_gateway\n" 
    234216"  %s vpn-disconnect vpn_gateway\n" 
    235 "\n" 
     217"  %s show-event\n" 
     218"  %s logout-user login\n""\n" 
    236219"    <protocol>: \"isakmp\", \"esp\" or \"ah\".\n" 
    237220"        In the case of \"show-sa\" or \"flush-sa\", you can use \"ipsec\".\n" 
    238221"\n" 
     
    240223"            : {\"esp\",\"ah\"} <family> <src/prefixlen/port> <dst/prefixlen/port>\n" 
    241224"                              <ul_proto>\n" 
    242225"    <family>: \"inet\" or \"inet6\"\n" 
    243 "    <ul_proto>: \"icmp\", \"tcp\", \"udp\" or \"any\"\n", 
    244         pname, pname, pname, pname, pname, pname, pname); 
     226"    <ul_proto>: \"icmp\", \"tcp\", \"udp\", \"gre\" or \"any\"\n", 
     227    pname, pname, pname, pname, pname, pname, pname, pname, pname, pname); 
    245228} 
    246229 
    247230/* 
     
    312295 
    313296        vfree(combuf); 
    314297 
    315         if (com_recv(&combuf) != 0) 
    316                 goto bad; 
    317         if (handle_recv(combuf) != 0) 
    318                 goto bad; 
    319  
    320         vfree(combuf); 
     298        do { 
     299                if (com_recv(&combuf) != 0) 
     300                        goto bad; 
     301                if (handle_recv(combuf) != 0) 
     302                        goto bad; 
     303                vfree(combuf); 
     304        } while (evt_quit_event != 0); 
    321305 
    322         if (evt_filter != EVTF_NONE) 
    323                 if (evt_poll() != 0) 
    324                         goto bad;        
    325          
     306        close(so); 
    326307        exit(0); 
    327308 
    328     bad: 
     309bad: 
     310        close(so); 
     311        if (errno == EEXIST) 
     312                exit(0); 
    329313        exit(1); 
    330314} 
    331315 
    332 int 
    333 evt_poll(void) { 
    334         struct timeval tv; 
    335         vchar_t *recvbuf; 
    336         vchar_t *sendbuf; 
    337  
    338         if ((sendbuf = f_getevt(0, NULL)) == NULL) 
    339                 errx(1, "Cannot make combuf"); 
    340  
    341  
    342         while (evt_filter & (EVTF_LOOP|EVTF_PURGE)) { 
    343                 /* handle_recv closes the socket time, so open it each time */ 
    344                 com_init(); 
    345  
    346                 if (com_send(sendbuf) != 0) 
    347                         errx(1, "Cannot send combuf"); 
    348  
    349                 if (com_recv(&recvbuf) == 0) { 
    350                         handle_recv(recvbuf); 
    351                         vfree(recvbuf); 
    352                 } 
    353  
    354                 tv.tv_sec = 0; 
    355                 tv.tv_usec = 10; 
    356                 (void)select(0, NULL, NULL, NULL, &tv); 
    357         } 
    358  
    359         vfree(sendbuf); 
    360         return 0; 
    361 } 
    362316 
    363317/* %%% */ 
    364318/* 
     
    422376        vchar_t *buf; 
    423377        struct admin_com *head; 
    424378 
    425         /* 
    426          * There are 3 ways of getting here 
    427          * 1) racoonctl vc => evt_filter = (EVTF_LOOP|EVTF_CFG| ... ) 
    428          * 2) racoonctl es => evt_filter = EVTF_NONE 
    429          * 3) racoonctl es -l => evt_filter = EVTF_LOOP 
    430          * Catch the second case: show-event is here to purge all 
    431          */ 
    432         if (evt_filter == EVTF_NONE) 
    433                 evt_filter = (EVTF_ALL|EVTF_PURGE); 
    434  
    435         if ((ac >= 1) && (strcmp(av[0], "-l") == 0)) 
    436                 evt_filter |= EVTF_LOOP; 
    437  
    438         if (ac >= 2) 
     379        evt_quit_event = -1; 
     380        if (ac >= 1) 
    439381                errx(1, "too many arguments"); 
    440382 
    441383        buf = vmalloc(sizeof(*head)); 
     
    653595        char *id = NULL; 
    654596        char *key = NULL; 
    655597        struct admin_com_psk *acp; 
     598        int wait = 0; 
    656599 
    657600        if (ac < 1) 
    658601                errx(1, "insufficient arguments"); 
     
    673616                ac -= 2; 
    674617        } 
    675618 
     619        if (ac >= 1 && strcmp(av[0], "-w") == 0) { 
     620                wait = 1; 
     621                av++; 
     622                ac--; 
     623        } 
     624 
    676625        /* need protocol */ 
    677626        if (ac < 1) 
    678627                errx(1, "insufficient arguments"); 
     
    687636                index = get_index(ac, av); 
    688637                if (index == NULL) 
    689638                        return NULL; 
     639                if (wait) 
     640                        evt_quit_event = EVTT_PHASE1_MODE_CFG; 
    690641                break; 
    691642        case ADMIN_PROTO_AH: 
    692643        case ADMIN_PROTO_ESP: 
    693644                index = get_index(ac, av); 
    694645                if (index == NULL) 
    695646                        return NULL; 
     647                if (wait) 
     648                        evt_quit_event = EVTT_PHASE2_UP; 
    696649                break; 
    697650        default: 
    698651                errno = EPROTONOSUPPORT; 
     
    749702        if (ac < 1) 
    750703                errx(1, "insufficient arguments"); 
    751704 
    752         evt_filter = (EVTF_LOOP|EVTF_CFG|EVTF_CFG_STOP|EVTF_ERR|EVTF_ERR_STOP); 
    753         time(&evt_start); 
     705        evt_quit_event = EVTT_PHASE1_MODE_CFG; 
    754706         
    755707        /* Optional -u identity */ 
    756708        if (strcmp(av[0], "-u") == 0) { 
     
    814766        if (ac > 1) 
    815767                warnx("Extra arguments"); 
    816768 
    817         evt_filter =  
    818             (EVTF_PH1DOWN|EVTF_PH1DOWN_STOP|EVTF_LOOP|EVTF_ERR|EVTF_ERR_STOP); 
     769        evt_quit_event = EVTT_PHASE1_DOWN; 
    819770 
    820771        nav[nac++] = isakmp; 
    821772        nav[nac++] = inet; 
     
    13371288 
    13381289 
    13391290void 
    1340 print_evt(buf, len) 
    1341         caddr_t buf; 
    1342         int len; 
     1291print_evt(evtdump) 
     1292        struct evt_common *evtdump; 
    13431293{ 
    1344         struct evtdump *evtdump = (struct evtdump *)buf; 
    13451294        int i; 
    13461295        char *srcstr; 
    13471296        char *dststr; 
    13481297         
    1349         for (i = 0; evtmsg[i].msg; i++) 
    1350                 if (evtmsg[i].type == evtdump->type) 
    1351                         break;                           
    1352          
    1353         if (evtmsg[i].msg == NULL)  
    1354                 printf("Event %d: ", evtdump->type); 
     1298        for (i = 0; i < sizeof(evtmsg) / sizeof(evtmsg[0]); i++) 
     1299                if (evtmsg[i].type == evtdump->ec_type) 
     1300                        break; 
     1301 
     1302        if (evtmsg[i].msg == NULL) 
     1303                printf("Event %d: ", evtdump->ec_type); 
    13551304        else 
    13561305                printf("%s : ", evtmsg[i].msg); 
    13571306 
    1358         if ((srcstr = saddr2str((struct sockaddr *)&evtdump->src)) == NULL) 
     1307        if ((srcstr = saddr2str((struct sockaddr *)&evtdump->ec_ph1src)) == NULL) 
    13591308                printf("unknown"); 
    13601309        else  
    13611310                printf("%s", srcstr); 
    13621311        printf(" -> "); 
    1363         if ((dststr = saddr2str((struct sockaddr *)&evtdump->dst)) == NULL) 
     1312        if ((dststr = saddr2str((struct sockaddr *)&evtdump->ec_ph1dst)) == NULL) 
    13641313                printf("unknown"); 
    13651314        else  
    13661315                printf("%s", dststr); 
    13671316        printf("\n"); 
    1368  
    1369         return; 
    1370 } 
    1371  
    1372 void 
    1373 print_err(buf, len) 
    1374         caddr_t buf; 
    1375         int len; 
    1376 { 
    1377         struct evtdump *evtdump = (struct evtdump *)buf; 
    1378         int i; 
    1379          
    1380          
    1381         for (i = 0; evtmsg[i].msg; i++) 
    1382                 if (evtmsg[i].type == evtdump->type) 
    1383                         break;                           
    1384  
    1385         if (evtmsg[i].level != ERROR) 
    1386                 return; 
    1387          
    1388         if (evtmsg[i].msg == NULL)  
    1389                 printf("Error: Event %d\n", evtdump->type); 
    1390         else 
    1391                 printf("Error: %s\n", evtmsg[i].msg); 
    1392  
    1393         if (evt_filter & EVTF_ERR_STOP) 
    1394                 evt_filter &= ~EVTF_LOOP; 
    1395  
    1396         return; 
    1397 } 
    1398  
    1399 /* 
    1400  * Print a message when phase 1 SA goes down 
    1401  */ 
    1402 void 
    1403 print_ph1down(buf, len) 
    1404         caddr_t buf; 
    1405         int len; 
    1406 { 
    1407         struct evtdump *evtdump = (struct evtdump *)buf; 
    1408          
    1409         if (evtdump->type != EVTT_PHASE1_DOWN) 
    1410                 return; 
    1411  
    1412         printf("VPN connexion terminated\n"); 
    1413  
    1414         if (evt_filter & EVTF_PH1DOWN_STOP) 
    1415                 evt_filter &= ~EVTF_LOOP; 
    1416          
    1417         return; 
    14181317} 
    14191318 
    14201319/* 
     
    14251324        caddr_t buf; 
    14261325        int len; 
    14271326{ 
    1428         struct evtdump *evtdump = (struct evtdump *)buf; 
     1327        struct evt_common *evtdump = (struct evt_common *)buf; 
    14291328        struct isakmp_data *attr; 
    14301329        char *banner = NULL; 
    14311330        struct in_addr addr4; 
    14321331         
    14331332        memset(&addr4, 0, sizeof(addr4)); 
    14341333 
    1435         if (evtdump->type != EVTT_ISAKMP_CFG_DONE &&  
    1436             evtdump->type != EVTT_NO_ISAKMP_CFG) 
     1334        if (evtdump->ec_type != EVTT_PHASE1_MODE_CFG) 
    14371335                return; 
    14381336 
    14391337        len -= sizeof(*evtdump); 
     
    14871385                } 
    14881386        } 
    14891387         
    1490         if (evtdump->type == EVTT_ISAKMP_CFG_DONE) 
     1388        if (len > 0) 
    14911389                printf("Bound to address %s\n", inet_ntoa(addr4)); 
    14921390        else 
    14931391                printf("VPN connexion established\n"); 
     
    15081406                printf("\n"); 
    15091407                racoon_free(banner); 
    15101408        } 
    1511          
    1512         if (evt_filter & EVTF_CFG_STOP) 
    1513                 evt_filter &= ~EVTF_LOOP; 
    1514          
    1515         return; 
    15161409} 
    15171410         
    15181411 
     
    15631456                break; 
    15641457 
    15651458        case ADMIN_SHOW_EVT: { 
    1566                 struct evtdump *evtdump; 
     1459                struct evt_common *ec; 
    15671460 
    1568                 /* We got no event */ 
    1569                 if (len == 0) { 
    1570                         /* If we were purging the queue, it is now done */ 
    1571                         if (evt_filter & EVTF_PURGE) 
    1572                                 evt_filter &= ~EVTF_PURGE; 
     1461                /* We got no event? */ 
     1462                if (len == 0) 
    15731463                        break; 
    1574                 } 
     1464                if (len < sizeof(struct evt_common)) 
     1465                        errx(1, "Short buffer\n"); 
    15751466 
    1576                 if (len < sizeof(struct evtdump)) 
    1577                         errx(1, "Short buffer\n");               
    1578  
    1579                 /* Toss outdated events */ 
    1580                 evtdump = (struct evtdump *)buf; 
    1581                 if (evtdump->timestamp < evt_start) 
    1582                         break; 
    1583  
    1584                 if (evt_filter & EVTF_ALL) 
    1585                         print_evt(buf, len); 
    1586                 if (evt_filter & EVTF_ERR) 
    1587                         print_err(buf, len); 
    1588                 if (evt_filter & EVTF_CFG) 
    1589                         print_cfg(buf, len); 
    1590                 if (evt_filter & EVTF_PH1DOWN) 
    1591                         print_ph1down(buf, len); 
     1467                ec = (struct evt_common *) buf; 
     1468                if (evt_quit_event <= 0) 
     1469                        print_evt(ec); 
     1470                else if (evt_quit_event == ec->ec_type) { 
     1471                        switch (ec->ec_type) { 
     1472                        case EVTT_PHASE1_MODE_CFG: 
     1473                                print_cfg(ec, len); 
     1474                                break; 
     1475                        default: 
     1476                                print_evt(ec); 
     1477                                break; 
     1478                        }; 
     1479                        evt_quit_event = 0; 
     1480                } 
    15921481                break; 
    15931482        } 
    15941483 
     
    16451534                break; 
    16461535        } 
    16471536 
    1648         close(so); 
    16491537        return 0; 
    16501538 
    1651     bad: 
    1652         close(so); 
     1539bad: 
    16531540        return -1; 
    16541541} 
  • src/racoon/session.c

    old new  
    192192                /* scheduling */ 
    193193                timeout = schedular(); 
    194194 
     195                nfds = evt_get_fdmask(nfds, &rfds); 
    195196                error = select(nfds, &rfds, (fd_set *)0, (fd_set *)0, timeout); 
    196197                if (error < 0) { 
    197198                        switch (errno) { 
     
    211212                    (FD_ISSET(lcconf->sock_admin, &rfds))) 
    212213                        admin_handler(); 
    213214#endif 
     215                evt_handle_fdmask(&rfds); 
    214216 
    215217                for (p = lcconf->myaddrs; p; p = p->next) { 
    216218                        if (!p->addr) 
     
    451453                case SIGTERM:                    
    452454                        plog(LLV_INFO, LOCATION, NULL,  
    453455                            "caught signal %d\n", sig); 
    454                         EVT_PUSH(NULL, NULL, EVTT_RACOON_QUIT, NULL); 
     456                        evt_generic(EVTT_RACOON_QUIT, NULL); 
    455457                        pfkey_send_flush(lcconf->sock_pfkey,  
    456458                            SADB_SATYPE_UNSPEC); 
    457459#ifdef ENABLE_FASTQUIT 
Note: See TracBrowser for help on using the repository browser.