← Back to branch summary

~ubuntu-branches/ubuntu/utopic/strongswan/utopic

« back to all changes in this revision

Viewing changes to src/frontends/osx/charon-xpc/charon-xpc.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Davies
  • Date: 2014-01-20 19:00:59 UTC
  • mfrom: (1.2.6)
  • Revision ID: package-import@ubuntu.com-20140120190059-z8e4dl3g8cd09yi5
Tags: 5.1.2~dr3+git20130120-0ubuntu1
* Upstream Git snapshot for build fixes with regards to entropy.
* debian/rules:
  - Enforcing DEB_BUILD_OPTIONS=nostrip for library integrity checking.
  - Set TESTS_REDUCED_KEYLENGTHS to one generate smallest key-lengths in
    tests.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/frontends/osx/charon-xpc/charon-xpc.c
 
1
/*
 
2
 * Copyright (C) 2013 Martin Willi
 
3
 * Copyright (C) 2013 revosec AG
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify it
 
6
 * under the terms of the GNU General Public License as published by the
 
7
 * Free Software Foundation; either version 2 of the License, or (at your
 
8
 * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful, but
 
11
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
12
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
13
 * for more details.
 
14
 */
 
15
 
 
16
#include <sys/types.h>
 
17
#include <sys/utsname.h>
 
18
#include <unistd.h>
 
19
#include <stdio.h>
 
20
#include <signal.h>
 
21
#include <pthread.h>
 
22
 
 
23
#include <library.h>
 
24
#include <hydra.h>
 
25
#include <daemon.h>
 
26
#include <threading/thread.h>
 
27
#include <utils/backtrace.h>
 
28
 
 
29
#include "xpc_dispatch.h"
 
30
 
 
31
/**
 
32
 * XPC dispatcher class
 
33
 */
 
34
static xpc_dispatch_t *dispatcher;
 
35
 
 
36
/**
 
37
 * atexit() cleanup for dispatcher
 
38
 */
 
39
void dispatcher_cleanup()
 
40
{
 
41
        DESTROY_IF(dispatcher);
 
42
}
 
43
 
 
44
/**
 
45
 * Loglevel configuration
 
46
 */
 
47
static level_t levels[DBG_MAX];
 
48
 
 
49
/**
 
50
 * hook in library for debugging messages
 
51
 */
 
52
extern void (*dbg) (debug_t group, level_t level, char *fmt, ...);
 
53
 
 
54
/**
 
55
 * Logging hook for library logs, using stderr output
 
56
 */
 
57
static void dbg_stderr(debug_t group, level_t level, char *fmt, ...)
 
58
{
 
59
        va_list args;
 
60
 
 
61
        if (level <= 1)
 
62
        {
 
63
                va_start(args, fmt);
 
64
                fprintf(stderr, "00[%N] ", debug_names, group);
 
65
                vfprintf(stderr, fmt, args);
 
66
                fprintf(stderr, "\n");
 
67
                va_end(args);
 
68
        }
 
69
}
 
70
 
 
71
/**
 
72
 * Run the daemon and handle unix signals
 
73
 */
 
74
static int run()
 
75
{
 
76
        sigset_t set;
 
77
 
 
78
        sigemptyset(&set);
 
79
        sigaddset(&set, SIGINT);
 
80
        sigaddset(&set, SIGTERM);
 
81
        sigprocmask(SIG_BLOCK, &set, NULL);
 
82
 
 
83
        while (TRUE)
 
84
        {
 
85
                int sig;
 
86
 
 
87
                if (sigwait(&set, &sig))
 
88
                {
 
89
                        DBG1(DBG_DMN, "error while waiting for a signal");
 
90
                        return 1;
 
91
                }
 
92
                switch (sig)
 
93
                {
 
94
                        case SIGINT:
 
95
                                DBG1(DBG_DMN, "signal of type SIGINT received. Shutting down");
 
96
                                charon->bus->alert(charon->bus, ALERT_SHUTDOWN_SIGNAL, sig);
 
97
                                return 0;
 
98
                        case SIGTERM:
 
99
                                DBG1(DBG_DMN, "signal of type SIGTERM received. Shutting down");
 
100
                                charon->bus->alert(charon->bus, ALERT_SHUTDOWN_SIGNAL, sig);
 
101
                                return 0;
 
102
                        default:
 
103
                                DBG1(DBG_DMN, "unknown signal %d received. Ignored", sig);
 
104
                                break;
 
105
                }
 
106
        }
 
107
}
 
108
 
 
109
/**
 
110
 * Handle SIGSEGV/SIGILL signals raised by threads
 
111
 */
 
112
static void segv_handler(int signal)
 
113
{
 
114
        backtrace_t *backtrace;
 
115
 
 
116
        DBG1(DBG_DMN, "thread %u received %d", thread_current_id(), signal);
 
117
        backtrace = backtrace_create(2);
 
118
        backtrace->log(backtrace, NULL, TRUE);
 
119
        backtrace->destroy(backtrace);
 
120
 
 
121
        DBG1(DBG_DMN, "killing ourself, received critical signal");
 
122
        abort();
 
123
}
 
124
 
 
125
/**
 
126
 * Main function, starts the daemon.
 
127
 */
 
128
int main(int argc, char *argv[])
 
129
{
 
130
        struct sigaction action;
 
131
        struct utsname utsname;
 
132
        int group;
 
133
 
 
134
        dbg = dbg_stderr;
 
135
        atexit(library_deinit);
 
136
        if (!library_init(NULL))
 
137
        {
 
138
                exit(SS_RC_LIBSTRONGSWAN_INTEGRITY);
 
139
        }
 
140
        if (lib->integrity)
 
141
        {
 
142
                if (!lib->integrity->check_file(lib->integrity, "charon-xpc", argv[0]))
 
143
                {
 
144
                        exit(SS_RC_DAEMON_INTEGRITY);
 
145
                }
 
146
        }
 
147
        atexit(libhydra_deinit);
 
148
        if (!libhydra_init("charon-xpc"))
 
149
        {
 
150
                exit(SS_RC_INITIALIZATION_FAILED);
 
151
        }
 
152
        atexit(libcharon_deinit);
 
153
        if (!libcharon_init("charon-xpc"))
 
154
        {
 
155
                exit(SS_RC_INITIALIZATION_FAILED);
 
156
        }
 
157
        for (group = 0; group < DBG_MAX; group++)
 
158
        {
 
159
                levels[group] = LEVEL_CTRL;
 
160
        }
 
161
        charon->load_loggers(charon, levels, TRUE);
 
162
 
 
163
        lib->settings->set_default_str(lib->settings, "charon-xpc.port", "0");
 
164
        lib->settings->set_default_str(lib->settings, "charon-xpc.port_nat_t", "0");
 
165
        lib->settings->set_default_str(lib->settings,
 
166
                                                                "charon-xpc.close_ike_on_child_failure", "yes");
 
167
        if (!charon->initialize(charon,
 
168
                        lib->settings->get_str(lib->settings, "charon-xpc.load",
 
169
                                "nonce pkcs1 openssl keychain ctr ccm gcm kernel-libipsec "
 
170
                                "kernel-pfroute socket-default eap-identity eap-mschapv2 "
 
171
                                "eap-md5 xauth-generic osx-attr")))
 
172
        {
 
173
                exit(SS_RC_INITIALIZATION_FAILED);
 
174
        }
 
175
 
 
176
        if (uname(&utsname) != 0)
 
177
        {
 
178
                memset(&utsname, 0, sizeof(utsname));
 
179
        }
 
180
        DBG1(DBG_DMN, "Starting charon-xpc IKE daemon (strongSwan %s, %s %s, %s)",
 
181
                 VERSION, utsname.sysname, utsname.release, utsname.machine);
 
182
 
 
183
        /* add handler for SEGV and ILL,
 
184
         * INT, TERM and HUP are handled by sigwait() in run() */
 
185
        action.sa_handler = segv_handler;
 
186
        action.sa_flags = 0;
 
187
        sigemptyset(&action.sa_mask);
 
188
        sigaddset(&action.sa_mask, SIGINT);
 
189
        sigaddset(&action.sa_mask, SIGTERM);
 
190
        sigaddset(&action.sa_mask, SIGHUP);
 
191
        sigaction(SIGSEGV, &action, NULL);
 
192
        sigaction(SIGILL, &action, NULL);
 
193
        sigaction(SIGBUS, &action, NULL);
 
194
        action.sa_handler = SIG_IGN;
 
195
        sigaction(SIGPIPE, &action, NULL);
 
196
 
 
197
        pthread_sigmask(SIG_SETMASK, &action.sa_mask, NULL);
 
198
 
 
199
        dispatcher = xpc_dispatch_create();
 
200
        if (!dispatcher)
 
201
        {
 
202
                exit(SS_RC_INITIALIZATION_FAILED);
 
203
        }
 
204
        atexit(dispatcher_cleanup);
 
205
 
 
206
        charon->start(charon);
 
207
        return run();
 
208
}