First steps towards supporting W32.
[gnupg.git] / common / sysutils.c
1 /* sysutils.c -  system helpers
2  * Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG 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 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG 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
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19  * USA.
20  */
21
22 #include <config.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <unistd.h>
27 #include <errno.h>
28 #ifdef HAVE_STAT
29 #include <sys/stat.h>
30 #endif
31 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
32   #include <asm/sysinfo.h>
33   #include <asm/unistd.h>
34 #endif
35 #ifdef HAVE_SETRLIMIT
36   #include <time.h>
37   #include <sys/time.h>
38   #include <sys/resource.h>
39 #endif
40 #include "util.h"
41 #include "i18n.h"
42
43 #include "sysutils.h"
44
45 #if defined(__linux__) && defined(__alpha__) && __GLIBC__ < 2
46 #warning using trap_unaligned
47 static int
48 setsysinfo(unsigned long op, void *buffer, unsigned long size,
49                      int *start, void *arg, unsigned long flag)
50 {
51     return syscall(__NR_osf_setsysinfo, op, buffer, size, start, arg, flag);
52 }
53
54 void
55 trap_unaligned(void)
56 {
57     unsigned int buf[2];
58
59     buf[0] = SSIN_UACPROC;
60     buf[1] = UAC_SIGBUS | UAC_NOPRINT;
61     setsysinfo(SSI_NVPAIRS, buf, 1, 0, 0, 0);
62 }
63 #else
64 void
65 trap_unaligned(void)
66 {  /* dummy */
67 }
68 #endif
69
70
71 int
72 disable_core_dumps (void)
73 {
74 #ifdef HAVE_DOSISH_SYSTEM
75     return 0;
76 #else
77 # ifdef HAVE_SETRLIMIT
78     struct rlimit limit;
79
80     /* We only set the current limit unless we were not able to
81        retrieve the old value. */
82     if (getrlimit (RLIMIT_CORE, &limit))
83       limit.rlim_max = 0;
84     limit.rlim_cur = 0;
85     if( !setrlimit (RLIMIT_CORE, &limit) )
86         return 0;
87     if( errno != EINVAL && errno != ENOSYS )
88         log_fatal (_("can't disable core dumps: %s\n"), strerror(errno) );
89 #endif
90     return 1;
91 #endif
92 }
93
94 int
95 enable_core_dumps (void)
96 {
97 #ifdef HAVE_DOSISH_SYSTEM
98     return 0;
99 #else
100 # ifdef HAVE_SETRLIMIT
101     struct rlimit limit;
102
103     if (getrlimit (RLIMIT_CORE, &limit))
104       return 1;
105     limit.rlim_cur = limit.rlim_max;
106     setrlimit (RLIMIT_CORE, &limit);
107     return 1; /* We always return true because trhis function is
108                  merely a debugging aid. */
109 # endif
110     return 1;
111 #endif
112 }
113
114
115
116 /* Return a string which is used as a kind of process ID */
117 const byte *
118 get_session_marker( size_t *rlen )
119 {
120     static byte marker[SIZEOF_UNSIGNED_LONG*2];
121     static int initialized;
122
123     if ( !initialized ) {
124         volatile ulong aa, bb; /* we really want the uninitialized value */
125         ulong a, b;
126
127         initialized = 1;
128         /* Although this marker is guessable it is not easy to use
129          * for a faked control packet because an attacker does not
130          * have enough control about the time the verification does 
131          * take place.  Of course, we can add just more random but 
132          * than we need the random generator even for verification
133          * tasks - which does not make sense. */
134         a = aa ^ (ulong)getpid();
135         b = bb ^ (ulong)time(NULL);
136         memcpy( marker, &a, SIZEOF_UNSIGNED_LONG );
137         memcpy( marker+SIZEOF_UNSIGNED_LONG, &b, SIZEOF_UNSIGNED_LONG );
138     }
139     *rlen = sizeof(marker);
140     return marker;
141 }
142
143
144 #if 0 /* not yet needed - Note that this will require inclusion of
145          cmacros.am in Makefile.am */
146 int
147 check_permissions(const char *path,int extension,int checkonly)
148 {
149 #if defined(HAVE_STAT) && !defined(HAVE_DOSISH_SYSTEM)
150   char *tmppath;
151   struct stat statbuf;
152   int ret=1;
153   int isdir=0;
154
155   if(opt.no_perm_warn)
156     return 0;
157
158   if(extension && path[0]!=DIRSEP_C)
159     {
160       if(strchr(path,DIRSEP_C))
161         tmppath=make_filename(path,NULL);
162       else
163         tmppath=make_filename(GNUPG_LIBDIR,path,NULL);
164     }
165   else
166     tmppath=m_strdup(path);
167
168   /* It's okay if the file doesn't exist */
169   if(stat(tmppath,&statbuf)!=0)
170     {
171       ret=0;
172       goto end;
173     }
174
175   isdir=S_ISDIR(statbuf.st_mode);
176
177   /* Per-user files must be owned by the user.  Extensions must be
178      owned by the user or root. */
179   if((!extension && statbuf.st_uid != getuid()) ||
180      (extension && statbuf.st_uid!=0 && statbuf.st_uid!=getuid()))
181     {
182       if(!checkonly)
183         log_info(_("Warning: unsafe ownership on %s \"%s\"\n"),
184                  isdir?"directory":extension?"extension":"file",path);
185       goto end;
186     }
187
188   /* This works for both directories and files - basically, we don't
189      care what the owner permissions are, so long as the group and
190      other permissions are 0 for per-user files, and non-writable for
191      extensions. */
192   if((extension && (statbuf.st_mode & (S_IWGRP|S_IWOTH)) !=0) ||
193      (!extension && (statbuf.st_mode & (S_IRWXG|S_IRWXO)) != 0))
194     {
195       char *dir;
196
197       /* However, if the directory the directory/file is in is owned
198          by the user and is 700, then this is not a problem.
199          Theoretically, we could walk this test up to the root
200          directory /, but for the sake of sanity, I'm stopping at one
201          level down. */
202
203       dir= make_dirname (tmppath);
204       if(stat(dir,&statbuf)==0 && statbuf.st_uid==getuid() &&
205          S_ISDIR(statbuf.st_mode) && (statbuf.st_mode & (S_IRWXG|S_IRWXO))==0)
206         {
207           xfree (dir);
208           ret=0;
209           goto end;
210         }
211
212       m_free(dir);
213
214       if(!checkonly)
215         log_info(_("Warning: unsafe permissions on %s \"%s\"\n"),
216                  isdir?"directory":extension?"extension":"file",path);
217       goto end;
218     }
219
220   ret=0;
221
222  end:
223   m_free(tmppath);
224
225   return ret;
226
227 #endif /* HAVE_STAT && !HAVE_DOSISH_SYSTEM */
228
229   return 0;
230 }
231 #endif