chiark / gitweb /
cross-building: Do not include a makefile
[authbind.git] / libauthbind.c
1 /*
2  *  libauthbind.c - bind(2)-redirector library for authbind
3  *
4  *  authbind is Copyright (C) 1998 Ian Jackson
5  * 
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2, or (at your option)
9  *  any later version.
10  * 
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  * 
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software Foundation,
18  *  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 
19  * 
20  */
21
22 #include <dlfcn.h>
23 #include <stdio.h>
24 #include <sys/types.h>
25 #include <unistd.h>
26 #include <errno.h>
27 #include <stdlib.h>
28 #include <signal.h>
29 #include <string.h>
30 #include <sys/socket.h>
31 #include <sys/wait.h>
32 #include <netinet/in.h>
33
34 #include "authbind.h"
35
36 typedef void anyfn_type(void);
37 typedef int bindfn_type(int fd, const struct sockaddr *addr, socklen_t addrlen);
38
39 #define STDERRSTR_CONST(m) write(2,m,sizeof(m)-1)
40 #define STDERRSTR_STRING(m) write(2,m,strlen(m))
41
42 static anyfn_type *find_any(const char *name) {
43   static const char *dlerr;
44   anyfn_type *kv;
45
46   kv= dlsym(RTLD_NEXT,name); if (kv) return kv;
47   dlerr= dlerror(); if (!dlerr) dlerr= "dlsym() failed for no reason";
48   STDERRSTR_CONST("libauthbind: error finding original version of ");
49   STDERRSTR_STRING(name);
50   STDERRSTR_CONST(": ");
51   STDERRSTR_STRING(dlerr);
52   STDERRSTR_STRING("\n");
53   errno= ENOSYS;
54   return 0;
55 }
56
57 static bindfn_type find_bind, *old_bind= find_bind;
58
59 int find_bind(int fd, const struct sockaddr *addr, socklen_t addrlen) {
60   anyfn_type *anyfn;
61   anyfn= find_any("bind"); if (!anyfn) return -1;
62   old_bind= (bindfn_type*)anyfn;
63   return old_bind(fd,addr,addrlen);
64 }
65
66 static int exiterrno(int e) {
67   _exit(e>0 && e<128 ? e : -1);
68 }
69
70 static void removepreload(void) {
71   const char *myself, *found;
72   char *newval, *preload;
73   int lpreload, lmyself, before, after;
74
75   preload= getenv(PRELOAD_VAR);
76   myself= getenv(AUTHBINDLIB_VAR);
77   if (!myself || !preload) return;
78
79   lpreload= strlen(preload);
80   lmyself= strlen(myself);
81
82   if (lmyself < 1 || lpreload<lmyself) return;
83   if (lpreload==lmyself) {
84     if (!strcmp(preload,myself)) unsetenv(PRELOAD_VAR);
85     return;
86   }
87   if (!memcmp(preload,myself,lmyself) && preload[lmyself]==':') {
88     before= 0; after= lpreload-(lmyself+1);
89   } else if (!memcmp(preload+lpreload-lmyself,myself,lmyself) &&
90              preload[lpreload-(lmyself+1)]==':') {
91     before= lpreload-(lmyself+1); after= 0;
92   } else {
93     if (lpreload<lmyself+2) return;
94     found= preload+1;
95     for (;;) {
96       found= strstr(found,myself); if (!found) return;
97       if (found > preload+lpreload-(lmyself+1)) return;
98       if (found[-1]==':' && found[lmyself]==':') break;
99       found++;
100     }
101     before= found-preload;
102     after= lpreload-(before+lmyself+1);
103   }
104   newval= malloc(before+after+1);
105   if (newval) {
106     memcpy(newval,preload,before);
107     strcpy(newval+before,preload+lpreload-after);
108     if (setenv(PRELOAD_VAR,newval,1)) return;
109     free(newval);
110   }
111   strcpy(preload+before,preload+lpreload-after);
112   return;
113 }
114
115 int _init(void);
116 int _init(void) {
117   char *levels;
118   int levelno;
119
120   /* If AUTHBIND_LEVELS is
121    *  unset => always strip from preload
122    *  set and starts with `y' => never strip from preload, keep AUTHBIND_LEVELS
123    *  set to integer > 1 => do not strip now, subtract one from AUTHBIND_LEVELS
124    *  set to integer 1 => do not strip now, unset AUTHBIND_LEVELS
125    *  set to empty string or 0 => strip now, unset AUTHBIND_LEVELS
126    */
127   levels= getenv(AUTHBIND_LEVELS_VAR);
128   if (levels) {
129     if (levels[0]=='y') return 0;
130     levelno= atoi(levels);
131     if (levelno > 0) {
132       levelno--;
133       if (levelno > 0) sprintf(levels,"%d",levelno);
134       else unsetenv(AUTHBIND_LEVELS_VAR);
135       return 0;
136     }
137     unsetenv(AUTHBIND_LEVELS_VAR);
138   }
139   removepreload();
140   return 0;
141 }
142
143 static const int evilsignals[]= { SIGFPE, SIGILL, SIGSEGV, SIGBUS, 0 };
144
145 int bind(int fd, const struct sockaddr *addr, socklen_t addrlen) {
146   pid_t child, rchild;
147   char portarg[5], addrarg[33];
148   const char *afarg;
149   int i, r, status, restore_sigchild;
150   const int *evilsignal;
151   sigset_t block, saved;
152   struct sigaction old_sigchild;
153   unsigned int portval;
154
155   switch (addr->sa_family) {
156   case AF_INET:
157     portval = ((struct sockaddr_in*)addr)->sin_port;
158     if (addrlen != sizeof(struct sockaddr_in)) goto bail;
159     break;
160   case AF_INET6:
161     portval = ((struct sockaddr_in6*)addr)->sin6_port;
162     if (addrlen != sizeof(struct sockaddr_in6)) goto bail;
163     break;
164   default:
165     goto bail;
166   }
167
168   if (!geteuid() || portval == 0 || ntohs(portval) >= IPPORT_RESERVED) {
169   bail:
170     return old_bind(fd,addr,addrlen);
171   }
172
173   sigfillset(&block);
174   for (evilsignal=evilsignals;
175        *evilsignal;
176        evilsignal++)
177     sigdelset(&block,*evilsignal);
178   if (sigprocmask(SIG_BLOCK,&block,&saved)) return -1;
179
180   switch (addr->sa_family) {
181   case AF_INET:
182     afarg = 0;
183     sprintf(addrarg,"%08lx",
184             ((unsigned long)(((struct sockaddr_in*)addr)->sin_addr.s_addr))
185             &0x0ffffffffUL);
186     break;
187   case AF_INET6:
188     afarg = "6";
189     for (i=0; i<16; i++)
190       sprintf(addrarg+i*2,"%02x",
191               ((struct sockaddr_in6*)addr)->sin6_addr.s6_addr[i]);
192     break;
193   default:
194     abort();
195   }
196   sprintf(portarg,"%04x",
197           portval&0x0ffff);
198
199   restore_sigchild= 0;
200   if (sigaction(SIGCHLD,NULL,&old_sigchild)) return -1;
201   if (old_sigchild.sa_handler == SIG_IGN) {
202     struct sigaction new_sigchild;
203
204     new_sigchild.sa_handler= SIG_DFL;
205     sigemptyset(&new_sigchild.sa_mask);
206     new_sigchild.sa_flags= 0;
207     if (sigaction(SIGCHLD,&new_sigchild,&old_sigchild)) return -1;
208     restore_sigchild= 1;
209   }
210
211   child= fork(); if (child==-1) goto x_err;
212
213   if (!child) {
214     if (dup2(fd,0)) exiterrno(errno);
215     removepreload();
216     execl(HELPER,HELPER,addrarg,portarg,afarg,(char*)0);
217     status= errno > 0 && errno < 127 ? errno : 127;
218     STDERRSTR_CONST("libauthbind: possible installation problem - "
219                     "could not invoke " HELPER "\n");
220     exiterrno(status);
221   }
222
223   rchild= waitpid(child,&status,0);
224   if (rchild==-1) goto x_err;
225   if (rchild!=child) { errno= ECHILD; goto x_err; }
226
227   if (WIFEXITED(status)) {
228     if (WEXITSTATUS(status)) {
229       errno= WEXITSTATUS(status);
230       if (errno >= 127) errno= ENXIO;
231       goto x_err;
232     }
233     r= 0;
234     goto x;
235   } else {
236     errno= ENOSYS;
237     goto x_err;
238   }
239
240 x_err:
241   r= -1;
242 x:
243   if (sigprocmask(SIG_SETMASK,&saved,0)) abort();
244   if (restore_sigchild) {
245     if (sigaction(SIGCHLD,&old_sigchild,NULL)) return -1;
246     if (old_sigchild.sa_handler == SIG_IGN) {
247       int discard;
248       while (waitpid(-1, &discard, WNOHANG) > 0)
249         ;
250     }
251   }
252   return r;
253 }