Cleanup logging.
[apps/pfixtools.git] / postlicyd / main-postlicyd.c
1 /******************************************************************************/
2 /*          pfixtools: a collection of postfix related tools                  */
3 /*          ~~~~~~~~~                                                         */
4 /*  ________________________________________________________________________  */
5 /*                                                                            */
6 /*  Redistribution and use in source and binary forms, with or without        */
7 /*  modification, are permitted provided that the following conditions        */
8 /*  are met:                                                                  */
9 /*                                                                            */
10 /*  1. Redistributions of source code must retain the above copyright         */
11 /*     notice, this list of conditions and the following disclaimer.          */
12 /*  2. Redistributions in binary form must reproduce the above copyright      */
13 /*     notice, this list of conditions and the following disclaimer in the    */
14 /*     documentation and/or other materials provided with the distribution.   */
15 /*  3. The names of its contributors may not be used to endorse or promote    */
16 /*     products derived from this software without specific prior written     */
17 /*     permission.                                                            */
18 /*                                                                            */
19 /*  THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND   */
20 /*  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE     */
21 /*  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR        */
22 /*  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS    */
23 /*  BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR    */
24 /*  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF      */
25 /*  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS  */
26 /*  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN   */
27 /*  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)   */
28 /*  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF    */
29 /*  THE POSSIBILITY OF SUCH DAMAGE.                                           */
30 /******************************************************************************/
31
32 /*
33  * Copyright © 2006-2007 Pierre Habouzit
34  * Copyright © 2008 Florent Bruneau
35  */
36
37 #include <getopt.h>
38
39 #include "buffer.h"
40 #include "common.h"
41 #include "epoll.h"
42 #include "policy_tokens.h"
43 #include "server.h"
44 #include "query.h"
45 #include "config.h"
46
47 #define DAEMON_NAME             "postlicyd"
48 #define DEFAULT_PORT            10000
49 #define RUNAS_USER              "nobody"
50 #define RUNAS_GROUP             "nogroup"
51
52 DECLARE_MAIN
53
54 static void *query_starter(server_t* server)
55 {
56     return query_new();
57 }
58
59 static bool config_refresh(void *config)
60 {
61     return config_reload(config);
62 }
63
64 __attribute__((format(printf,2,0)))
65 static void policy_answer(server_t *pcy, const char *fmt, ...)
66 {
67     va_list args;
68     const query_t* query = pcy->data;
69
70     buffer_addstr(&pcy->obuf, "action=");
71     va_start(args, fmt);
72     buffer_addvf(&pcy->obuf, fmt, args);
73     va_end(args);
74     buffer_addstr(&pcy->obuf, "\n\n");
75     buffer_consume(&pcy->ibuf, query->eoq - pcy->ibuf.data);
76     epoll_modify(pcy->fd, EPOLLIN | EPOLLOUT, pcy);
77 }
78
79 static bool policy_process(server_t *pcy, const config_t *config)
80 {
81     const query_t* query = pcy->data;
82     const filter_t *filter;
83     if (config->entry_points[query->state] == -1) {
84         warn("no filter defined for current protocol_state (%d)", query->state);
85         return false;
86     }
87     filter = array_ptr(config->filters, config->entry_points[query->state]);
88     while (true) {
89         const filter_hook_t *hook = filter_run(filter, query);
90         if (hook == NULL) {
91             warn("request client=%s, from=<%s>, to=<%s>: aborted",
92                  query->client_name,
93                  query->sender == NULL ? "undefined" : query->sender,
94                  query->recipient == NULL ? "undefined" : query->recipient);
95             return false;
96         } else if (hook->postfix) {
97             info("request client=%s, from=<%s>, to=<%s>: "
98                  "awswer %s from filter %s: \"%s\"",
99                  query->client_name,
100                  query->sender == NULL ? "undefined" : query->sender,
101                  query->recipient == NULL ? "undefined" : query->recipient,
102                  htokens[hook->type], filter->name, hook->value);
103             policy_answer(pcy, "%s", hook->value);
104             return true;
105         } else {
106             notice("request client=%s, from=<%s>, to=<%s>: "
107                    "awswer %s from filter %s: next filter %s",
108                    query->client_name,
109                    query->sender == NULL ? "undefined" : query->sender,
110                    query->recipient == NULL ? "undefined" : query->recipient,
111                    htokens[hook->type], filter->name,
112                    (array_ptr(config->filters, hook->filter_id))->name);
113             filter = array_ptr(config->filters, hook->filter_id);
114         }
115     }
116 }
117
118 static int policy_run(server_t *pcy, void* vconfig)
119 {
120     ssize_t search_offs = MAX(0, (ssize_t)(pcy->ibuf.len - 1));
121     int nb = buffer_read(&pcy->ibuf, pcy->fd, -1);
122     const char *eoq;
123     query_t  *query  = pcy->data;
124     const config_t *config = vconfig;
125
126     if (nb < 0) {
127         if (errno == EAGAIN || errno == EINTR)
128             return 0;
129         UNIXERR("read");
130         return -1;
131     }
132     if (nb == 0) {
133         if (pcy->ibuf.len)
134             err("unexpected end of data");
135         return -1;
136     }
137
138     if (!(eoq = strstr(pcy->ibuf.data + search_offs, "\n\n")))
139         return 0;
140
141     if (!query_parse(pcy->data, pcy->ibuf.data))
142         return -1;
143     query->eoq = eoq + strlen("\n\n");
144     epoll_modify(pcy->fd, 0, pcy);
145     return policy_process(pcy, config) ? 0 : -1;
146 }
147
148 int start_listener(int port)
149 {
150     return start_server(port, NULL, NULL);
151 }
152
153 /* administrivia {{{ */
154
155 void usage(void)
156 {
157     fputs("usage: "DAEMON_NAME" [options] config\n"
158           "\n"
159           "Options:\n"
160           "    -l <port>    port to listen to\n"
161           "    -p <pidfile> file to write our pid to\n"
162           "    -f           stay in foreground\n"
163           "    -d           grow logging level\n"
164           "    -u           unsafe mode (don't drop privileges)\n"
165          , stderr);
166 }
167
168 /* }}} */
169
170 int main(int argc, char *argv[])
171 {
172     bool unsafe = false;
173     const char *pidfile = NULL;
174     bool daemonize = true;
175     int port = DEFAULT_PORT;
176     bool port_from_cli = false;
177
178     for (int c = 0; (c = getopt(argc, argv, "ufd" "l:p:")) >= 0; ) {
179         switch (c) {
180           case 'p':
181             pidfile = optarg;
182             break;
183           case 'u':
184             unsafe = true;
185             break;
186           case 'l':
187             port = atoi(optarg);
188             port_from_cli = true;
189             break;
190           case 'f':
191             daemonize = false;
192             break;
193           case 'd':
194             ++log_level;
195             break;
196           default:
197             usage();
198             return EXIT_FAILURE;
199         }
200     }
201
202     if (argc - optind != 1) {
203         usage();
204         return EXIT_FAILURE;
205     }
206
207     if (drop_privileges(RUNAS_USER, RUNAS_GROUP) < 0) {
208         crit("unable to drop privileges");
209         return EXIT_FAILURE;
210     }
211
212     config_t *config = config_read(argv[optind]);
213     if (config == NULL) {
214         return EXIT_FAILURE;
215     }
216     if (port_from_cli || config->port == 0) {
217         config->port = port;
218     }
219
220     if (common_setup(pidfile, true, NULL, NULL, daemonize) != EXIT_SUCCESS
221         || start_listener(config->port) < 0) {
222         config_delete(&config);
223         return EXIT_FAILURE;
224     } else {
225         int res = server_loop(query_starter, (delete_client_t)query_delete,
226                               policy_run, config_refresh, config);
227         config_delete(&config);
228         return res;
229     }
230 }