Apply 61_fix_ru_siteowner.patch
[mspang/vmailman.git] / src / common.c
1 /* common.c --- Common routines, constants, etc.  Used by all the wrappers.
2  *
3  * Copyright (C) 1998-2005 by the Free Software Foundation, Inc.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
18  * USA.
19  */
20
21 #include "common.h"
22
23 /* Passed in by configure. */
24 #define SCRIPTDIR PREFIX "/scripts/"         /* trailing slash */
25 #define MODULEDIR PREFIX                     /* no trailing slash */
26
27 const char* scriptdir = SCRIPTDIR;
28 const char* moduledir = MODULEDIR;
29 char* python = PYTHON;
30
31 /* Global variable used as a flag */
32 int running_as_cgi = 0;
33
34
35 \f
36 /* Some older systems don't define strerror().  Provide a replacement that is
37  * good enough for our purposes.
38  */
39 #ifndef HAVE_STRERROR
40
41 extern char *sys_errlist[];
42 extern int sys_nerr;
43
44 char* strerror(int errno)
45 {
46         if (errno < 0 || errno >= sys_nerr) {
47                 return "unknown error";
48         }
49         else {
50                 return sys_errlist[errno];
51         }
52 }
53
54 #endif /* ! HAVE_STRERROR */
55
56
57 \f
58 /* Report on errors and exit
59  */
60 #define BUFSIZE 1024
61
62 void
63 fatal(const char* ident, int exitcode, char* format, ...)
64 {
65 #ifndef HAVE_VSNPRINTF
66         /* A replacement is provided in vsnprintf.c for ancient systems still
67          * lacking one in their C library.
68          */
69         int vsnprintf(char*, size_t, const char*, va_list);
70 #endif /* !HAVE_VSNPRINTF */
71
72         char log_entry[BUFSIZE];
73
74         va_list arg_ptr;
75         va_start(arg_ptr, format);
76
77         vsnprintf(log_entry, BUFSIZE, format, arg_ptr);
78         va_end(arg_ptr);
79
80 #ifdef HAVE_SYSLOG
81         /* Write to the console, maillog is often mostly ignored, and root
82          * should definitely know about any problems.
83          */
84         openlog(ident, LOG_CONS, LOG_MAIL);
85         syslog(LOG_ERR, "%s\n", log_entry);
86         closelog();
87 #endif /* HAVE_SYSLOG */
88
89 #ifdef HELPFUL
90         /* If we're running as a CGI script, we also want to write the log
91          * file out as HTML, so the admin who is probably trying to debug his
92          * installation will have a better clue as to what's going on.
93          *
94          * Otherwise, print to stderr a short message, hopefully returned to
95          * the sender by the MTA.
96          */
97         if (running_as_cgi) {
98                 printf("Content-type: text/html\n\n");
99                 printf("<head>\n");
100                 printf("<title>Mailman CGI error!!!</title>\n");
101                 printf("</head><body>\n");
102                 printf("<h1>Mailman CGI error!!!</h1>\n");
103                 printf("The Mailman CGI wrapper encountered a fatal error. ");
104                 printf("This entry is being stored in your syslog:");
105                 printf("\n<pre>\n");
106                 printf("%s", log_entry);
107                 printf("</pre>\n");
108         }
109         else
110                 fprintf(stderr, "%s\n", log_entry);
111 #endif /* HELPFUL */
112         exit(exitcode);
113 }
114
115
116 \f
117 /* Is the parent process allowed to call us?
118  */
119 void
120 check_caller(const char* ident, const char* parentgroup)
121 {
122         GID_T mygid = getgid();
123         struct group *mygroup = getgrgid(mygid);
124         char* option;
125         char* server;
126         char* wrapper;
127
128         if (running_as_cgi) {
129                 option = "--with-cgi-gid";
130                 server = "web";
131                 wrapper = "CGI";
132         }
133         else {
134                 option = "--with-mail-gid";
135                 server = "mail";
136                 wrapper = "mail";
137         }
138
139         if (!mygroup)
140                 fatal(ident, GROUP_NAME_NOT_FOUND,
141                       "Failure to find group name for GID %d.  Mailman\n"
142                       "expected the %s wrapper to be executed as group\n"
143                       "\"%s\", but the system's %s server executed the\n"
144                       "wrapper as GID %d for which the name could not be\n"
145                       "found.  Try adding GID %d to your system as \"%s\",\n"
146                       "or tweak your %s server to run the wrapper as group\n"
147                       "\"%s\".",
148                       mygid, wrapper, parentgroup, server, mygid, mygid,
149                       parentgroup, server, parentgroup);
150
151         if (strcmp(parentgroup, mygroup->gr_name))
152                 fatal(ident, GROUP_MISMATCH,
153                       "Group mismatch error.  Mailman expected the %s\n"
154                       "wrapper script to be executed as group \"%s\", but\n"
155                       "the system's %s server executed the %s script as\n"
156                       "group \"%s\".  Try tweaking the %s server to run the\n"
157                       "script as group \"%s\", or re-run configure, \n"
158                       "providing the command line option `%s=%s'.",
159                       wrapper, parentgroup, server, wrapper, mygroup->gr_name,
160                       server, parentgroup, option, mygroup->gr_name);
161 }
162
163
164 \f
165 /* list of environment variables which are removed from the given
166  * environment.  Some may or may not be hand crafted and passed into
167  * the execv'd environment.
168  *
169  * TBD: The logic of this should be inverted.  IOW, we should audit the
170  * Mailman CGI code for those environment variables that are used, and
171  * specifically white list them, removing all other variables.  John Viega
172  * also suggests imposing a maximum size just in case Python doesn't handle
173  * them right (which it should because Python strings have no hard limits).
174  */
175 static char* killenvars[] = {
176         "PYTHONPATH=",
177         "PYTHONHOME=",
178         "PATH=",
179         NULL
180 };
181
182
183 \f
184 /* Run a Python script out of the script directory
185  *
186  * args[0] should be the abs path to the Python script to execute
187  * argv[1:] are other args for the script
188  * env may or may not contain PYTHONPATH, we'll substitute our own
189  *
190  * TBD: third argument env may not be universally portable
191  */
192 int
193 run_script(const char* script, int argc, char** argv, char** env)
194 {
195         const char envstr[] = "PYTHONPATH=";
196         const int envlen = strlen(envstr);
197
198         int envcnt = 0;
199         int i, j, status;
200         char** newenv;
201         char** newargv;
202
203         /* We need to set the real gid to the effective gid because there are
204          * some Linux systems which do not preserve the effective gid across
205          * popen() calls.  This breaks mail delivery unless the ~mailman/data
206          * directory is chown'd to the uid that runs mail programs, and that
207          * isn't a viable alternative.
208          */
209 #ifdef HAVE_SETREGID
210         status = setregid(getegid(), -1);
211         if (status)
212                 fatal(logident, SETREGID_FAILURE, "%s", strerror(errno));
213 #endif /* HAVE_SETREGID */
214
215         /* We want to tightly control how the CGI scripts get executed.
216          * For portability and security, the path to the Python executable
217          * is hard-coded into this C wrapper, rather than encoded in the #!
218          * line of the script that gets executed.  So we invoke those
219          * scripts by passing the script name on the command line to the
220          * Python executable.
221          *
222          * We also need to hack on the PYTHONPATH environment variable so
223          * that the path to the installed Mailman modules will show up
224          * first on sys.path.
225          *
226          */
227         for (envcnt = 0; env[envcnt]; envcnt++)
228                 ;
229
230         /* okay to be a little too big */
231         newenv = (char**)malloc(sizeof(char*) * (envcnt + 2));
232
233         /* filter out any troublesome environment variables */
234         for (i = 0, j = 0; i < envcnt; i++) {
235                 char** k = &killenvars[0];
236                 int keep = 1;
237                 while (*k) {
238                         if (!strncmp(*k, env[i], strlen(*k))) {
239                                 keep = 0;
240                                 break;
241                         }
242                         *k++;
243                 }
244                 if (keep)
245                         newenv[j++] = env[i];
246         }
247
248         /* Tack on our own version of PYTHONPATH, which should contain only
249          * the path to the Mailman package modules.
250          *
251          * $(PREFIX)/modules
252          */
253         newenv[j] = (char*)malloc(sizeof(char) * (
254                 strlen(envstr) +
255                 strlen(moduledir) +
256                 1));
257         strcpy(newenv[j], envstr);
258         strcat(newenv[j], moduledir);
259         j++;
260
261         newenv[j] = NULL;
262
263         /* Now put together argv.  This will contain first the absolute path
264          * to the Python executable, then the -S option (to speed executable
265          * start times), then the absolute path to the script, then any
266       * additional args passed in argv above.
267          */
268         newargv = (char**)malloc(sizeof(char*) * (argc + 3));
269         j = 0;
270         newargv[j++] = python;
271         newargv[j++] = "-S";
272         newargv[j] = (char*)malloc(sizeof(char) * (
273                 strlen(scriptdir) +
274                 strlen(script) +
275                 1));
276         strcpy(newargv[j], scriptdir);
277         strcat(newargv[j], script);
278
279         /* now tack on all the rest of the arguments.  we can skip argv's
280          * first two arguments because, for cgi-wrapper there is only argv[0].
281          * For mail-wrapper, argv[1] is the mail command (e.g. post,
282          * mailowner, or mailcmd) and argv[2] is the listname.  The mail
283          * command to execute gets passed in as this function's `script'
284          * parameter and becomes the argument to the python interpreter.  The
285          * list name therefore should become argv[2] to this process.
286          *
287          * TBD: have to make sure this works with alias-wrapper.
288          */
289         for (i=2, j++; i < argc; i++)
290                 newargv[j++] = argv[i];
291
292         newargv[j] = NULL;
293
294         /* return always means failure */
295         (void)execve(python, &newargv[0], &newenv[0]);
296         return EXECVE_FAILURE;
297 }
298
299
300 \f
301 /*
302  * Local Variables:
303  * c-file-style: "python"
304  * indent-tabs-mode: nil
305  * End:
306  */