Merge branch 'master' of ssh://gnunet.org/gnunet
[oweals/gnunet.git] / src / util / os_installation.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2006-2016 GNUnet e.V.
4
5      GNUnet is free software; you can redistribute it and/or modify
6      it under the terms of the GNU General Public License as published
7      by the Free Software Foundation; either version 3, or (at your
8      option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      General Public License for more details.
14
15      You should have received a copy of the GNU General Public License
16      along with GNUnet; see the file COPYING.  If not, write to the
17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18      Boston, MA 02110-1301, USA.
19 */
20
21 /**
22  * @file src/util/os_installation.c
23  * @brief get paths used by the program
24  * @author Milan
25  * @author Christian Fuchs
26  * @author Christian Grothoff
27  * @author Matthias Wachs
28  * @author Heikki Lindholm
29  * @author LRN
30  */
31 #include <sys/stat.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <unistd.h>
35 #include <unistr.h> /* for u16_to_u8 */
36
37 #include "platform.h"
38 #include "gnunet_util_lib.h"
39 #if DARWIN
40 #include <mach-o/ldsyms.h>
41 #include <mach-o/dyld.h>
42 #elif WINDOWS
43 #include <windows.h>
44 #endif
45
46
47 #define LOG(kind,...) GNUNET_log_from (kind, "util-os-installation", __VA_ARGS__)
48
49 #define LOG_STRERROR_FILE(kind,syscall,filename) GNUNET_log_from_strerror_file (kind, "util-os-installation", syscall, filename)
50
51
52 /**
53  * Default project data used for installation path detection
54  * for GNUnet (core).
55  */
56 static const struct GNUNET_OS_ProjectData default_pd = {
57   .libname = "libgnunetutil",
58   .project_dirname = "gnunet",
59   .binary_name = "gnunet-arm",
60   .env_varname = "GNUNET_PREFIX",
61   .base_config_varname = "GNUNET_BASE_CONFIG",
62   .bug_email = "gnunet-developers@gnu.org",
63   .homepage = "http://www.gnu.org/s/gnunet/",
64   .config_file = "gnunet.conf",
65   .user_config_file = "~/.config/gnunet.conf",
66 };
67
68 /**
69  * Which project data do we currently use for installation
70  * path detection? Never NULL.
71  */
72 static const struct GNUNET_OS_ProjectData *current_pd = &default_pd;
73
74 /**
75  * Return default project data used by 'libgnunetutil' for GNUnet.
76  */
77 const struct GNUNET_OS_ProjectData *
78 GNUNET_OS_project_data_default (void)
79 {
80   return &default_pd;
81 }
82
83
84 /**
85  * @return current project data.
86  */
87 const struct GNUNET_OS_ProjectData *
88 GNUNET_OS_project_data_get ()
89 {
90   return current_pd;
91 }
92
93
94 /**
95  * Setup OS subsystem with project data.
96  *
97  * @param pd project data used to determine paths
98  */
99 void
100 GNUNET_OS_init (const struct GNUNET_OS_ProjectData *pd)
101 {
102   GNUNET_assert (NULL != pd);
103   current_pd = pd;
104 }
105
106
107 #if LINUX
108 /**
109  * Try to determine path by reading /proc/PID/exe
110  *
111  * @return NULL on error
112  */
113 static char *
114 get_path_from_proc_maps ()
115 {
116   char fn[64];
117   char line[1024];
118   char dir[1024];
119   FILE *f;
120   char *lgu;
121
122   GNUNET_snprintf (fn, sizeof (fn), "/proc/%u/maps", getpid ());
123   if (NULL == (f = FOPEN (fn, "r")))
124     return NULL;
125   while (NULL != fgets (line, sizeof (line), f))
126   {
127     if ((1 ==
128          SSCANF (line, "%*x-%*x %*c%*c%*c%*c %*x %*2x:%*2x %*u%*[ ]%1023s", dir)) &&
129         (NULL != (lgu = strstr (dir,
130                                 current_pd->libname))))
131     {
132       lgu[0] = '\0';
133       FCLOSE (f);
134       return GNUNET_strdup (dir);
135     }
136   }
137   FCLOSE (f);
138   return NULL;
139 }
140
141
142 /**
143  * Try to determine path by reading /proc/PID/exe
144  *
145  * @return NULL on error
146  */
147 static char *
148 get_path_from_proc_exe ()
149 {
150   char fn[64];
151   char lnk[1024];
152   ssize_t size;
153   char *lep;
154
155   GNUNET_snprintf (fn, sizeof (fn), "/proc/%u/exe", getpid ());
156   size = readlink (fn, lnk, sizeof (lnk) - 1);
157   if (size <= 0)
158   {
159     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "readlink", fn);
160     return NULL;
161   }
162   GNUNET_assert (size < sizeof (lnk));
163   lnk[size] = '\0';
164   while ((lnk[size] != '/') && (size > 0))
165     size--;
166   GNUNET_asprintf (&lep,
167                    "/%s/libexec/",
168                    current_pd->project_dirname);
169   /* test for being in lib/gnunet/libexec/ or lib/MULTIARCH/gnunet/libexec */
170   if ( (size > strlen (lep)) &&
171        (0 == strcmp (lep,
172                      &lnk[size - strlen (lep)])) )
173     size -= strlen (lep) - 1;
174   GNUNET_free (lep);
175   if ((size < 4) || (lnk[size - 4] != '/'))
176   {
177     /* not installed in "/bin/" -- binary path probably useless */
178     return NULL;
179   }
180   lnk[size] = '\0';
181   return GNUNET_strdup (lnk);
182 }
183 #endif
184
185
186 #if WINDOWS
187 static HINSTANCE dll_instance;
188
189
190 /**
191  * GNUNET_util_cl_init() in common_logging.c is preferred.
192  * This function is only for thread-local storage (not used in GNUnet)
193  * and hInstance saving.
194  */
195 BOOL WINAPI
196 DllMain (HINSTANCE hinstDLL,
197          DWORD fdwReason,
198          LPVOID lpvReserved)
199 {
200   switch (fdwReason)
201   {
202     case DLL_PROCESS_ATTACH:
203       dll_instance = hinstDLL;
204       break;
205     case DLL_THREAD_ATTACH:
206       break;
207     case DLL_THREAD_DETACH:
208       break;
209     case DLL_PROCESS_DETACH:
210       break;
211   }
212   return TRUE;
213 }
214
215
216 /**
217  * Try to determine path with win32-specific function
218  *
219  * @return NULL on error
220  */
221 static char *
222 get_path_from_module_filename ()
223 {
224   size_t pathlen = 512;
225   DWORD real_pathlen;
226   wchar_t *idx;
227   wchar_t *modulepath = NULL;
228   char *upath;
229   uint8_t *u8_string;
230   size_t u8_string_length;
231
232   /* This braindead function won't tell us how much space it needs, so
233    * we start at 1024 and double the space up if it doesn't fit, until
234    * it fits, or we exceed the threshold.
235    */
236   do
237   {
238     pathlen = pathlen * 2;
239     modulepath = GNUNET_realloc (modulepath,
240                                  pathlen * sizeof (wchar_t));
241     SetLastError (0);
242     real_pathlen = GetModuleFileNameW (dll_instance,
243                                        modulepath,
244                                        pathlen * sizeof (wchar_t));
245   } while (real_pathlen >= pathlen && pathlen < 16*1024);
246   if (real_pathlen >= pathlen)
247     GNUNET_assert (0);
248   /* To be safe */
249   modulepath[real_pathlen] = '\0';
250
251   idx = modulepath + real_pathlen;
252   while ((idx > modulepath) && (*idx != L'\\') && (*idx != L'/'))
253     idx--;
254   *idx = L'\0';
255
256   /* Now modulepath holds full path to the directory where libgnunetutil is.
257    * This directory should look like <GNUNET_PREFIX>/bin or <GNUNET_PREFIX>.
258    */
259   if (wcschr (modulepath, L'/') || wcschr (modulepath, L'\\'))
260   {
261     /* At least one directory component (i.e. we're not in a root directory) */
262     wchar_t *dirname = idx;
263     while ((dirname > modulepath) && (*dirname != L'\\') && (*dirname != L'/'))
264       dirname--;
265     *dirname = L'\0';
266     if (dirname > modulepath)
267     {
268       dirname++;
269       /* Now modulepath holds full path to the parent directory of the directory
270        * where libgnunetutil is.
271        * dirname holds the name of the directory where libgnunetutil is.
272        */
273       if (wcsicmp (dirname, L"bin") == 0)
274       {
275         /* pass */
276       }
277       else
278       {
279         /* Roll back our changes to modulepath */
280         dirname--;
281         *dirname = L'/';
282       }
283     }
284   }
285
286   /* modulepath is GNUNET_PREFIX */
287   u8_string = u16_to_u8 (modulepath, wcslen (modulepath), NULL, &u8_string_length);
288   if (NULL == u8_string)
289     GNUNET_assert (0);
290
291   upath = GNUNET_malloc (u8_string_length + 1);
292   GNUNET_memcpy (upath, u8_string, u8_string_length);
293   upath[u8_string_length] = '\0';
294
295   free (u8_string);
296   GNUNET_free (modulepath);
297
298   return upath;
299 }
300 #endif
301
302
303 #if DARWIN
304 /**
305  * Signature of the '_NSGetExecutablePath" function.
306  *
307  * @param buf where to write the path
308  * @param number of bytes available in @a buf
309  * @return 0 on success, otherwise desired number of bytes is stored in 'bufsize'
310  */
311 typedef int
312 (*MyNSGetExecutablePathProto) (char *buf,
313                                size_t *bufsize);
314
315
316 /**
317  * Try to obtain the path of our executable using '_NSGetExecutablePath'.
318  *
319  * @return NULL on error
320  */
321 static char *
322 get_path_from_NSGetExecutablePath ()
323 {
324   static char zero = '\0';
325   char *path;
326   size_t len;
327   MyNSGetExecutablePathProto func;
328
329   path = NULL;
330   if (NULL == (func =
331                (MyNSGetExecutablePathProto) dlsym (RTLD_DEFAULT, "_NSGetExecutablePath")))
332     return NULL;
333   path = &zero;
334   len = 0;
335   /* get the path len, including the trailing \0 */
336   (void) func (path, &len);
337   if (0 == len)
338     return NULL;
339   path = GNUNET_malloc (len);
340   if (0 != func (path, &len))
341   {
342     GNUNET_free (path);
343     return NULL;
344   }
345   len = strlen (path);
346   while ((path[len] != '/') && (len > 0))
347     len--;
348   path[len] = '\0';
349   return path;
350 }
351
352
353 /**
354  * Try to obtain the path of our executable using '_dyld_image' API.
355  *
356  * @return NULL on error
357  */
358 static char *
359 get_path_from_dyld_image ()
360 {
361   const char *path;
362   char *p;
363   char *s;
364   unsigned int i;
365   int c;
366
367   c = _dyld_image_count ();
368   for (i = 0; i < c; i++)
369   {
370     if (((const void *) _dyld_get_image_header (i)) !=
371         ((const void *) &_mh_dylib_header) )
372       continue;
373     path = _dyld_get_image_name (i);
374     if ( (NULL == path) || (0 == strlen (path)) )
375       continue;
376     p = GNUNET_strdup (path);
377     s = p + strlen (p);
378     while ((s > p) && ('/' != *s))
379       s--;
380     s++;
381     *s = '\0';
382     return p;
383   }
384   return NULL;
385 }
386 #endif
387
388
389 /**
390  * Return the actual path to a file found in the current
391  * PATH environment variable.
392  *
393  * @param binary the name of the file to find
394  * @return path to binary, NULL if not found
395  */
396 static char *
397 get_path_from_PATH (const char *binary)
398 {
399   char *path;
400   char *pos;
401   char *end;
402   char *buf;
403   const char *p;
404
405   if (NULL == (p = getenv ("PATH")))
406     return NULL;
407 #if WINDOWS
408   /* On W32 look in CWD first. */
409   GNUNET_asprintf (&path, ".%c%s", PATH_SEPARATOR, p);
410 #else
411   path = GNUNET_strdup (p);     /* because we write on it */
412 #endif
413   buf = GNUNET_malloc (strlen (path) + strlen (binary) + 1 + 1);
414   pos = path;
415   while (NULL != (end = strchr (pos, PATH_SEPARATOR)))
416   {
417     *end = '\0';
418     sprintf (buf, "%s/%s", pos, binary);
419     if (GNUNET_DISK_file_test (buf) == GNUNET_YES)
420     {
421       pos = GNUNET_strdup (pos);
422       GNUNET_free (buf);
423       GNUNET_free (path);
424       return pos;
425     }
426     pos = end + 1;
427   }
428   sprintf (buf, "%s/%s", pos, binary);
429   if (GNUNET_YES == GNUNET_DISK_file_test (buf))
430   {
431     pos = GNUNET_strdup (pos);
432     GNUNET_free (buf);
433     GNUNET_free (path);
434     return pos;
435   }
436   GNUNET_free (buf);
437   GNUNET_free (path);
438   return NULL;
439 }
440
441
442 /**
443  * Try to obtain the installation path using the "GNUNET_PREFIX" environment
444  * variable.
445  *
446  * @return NULL on error (environment variable not set)
447  */
448 static char *
449 get_path_from_GNUNET_PREFIX ()
450 {
451   const char *p;
452
453   if ( (NULL != current_pd->env_varname) &&
454        (NULL != (p = getenv (current_pd->env_varname))) )
455     return GNUNET_strdup (p);
456   if ( (NULL != current_pd->env_varname_alt) &&
457        (NULL != (p = getenv (current_pd->env_varname_alt))) )
458     return GNUNET_strdup (p);
459   return NULL;
460 }
461
462
463 /**
464  * @brief get the path to GNUnet bin/ or lib/, prefering the lib/ path
465  * @author Milan
466  *
467  * @return a pointer to the executable path, or NULL on error
468  */
469 static char *
470 os_get_gnunet_path ()
471 {
472   char *ret;
473
474   if (NULL != (ret = get_path_from_GNUNET_PREFIX ()))
475     return ret;
476 #if LINUX
477   if (NULL != (ret = get_path_from_proc_maps ()))
478     return ret;
479   /* try path *first*, before /proc/exe, as /proc/exe can be wrong */
480   if ( (NULL != current_pd->binary_name) &&
481        (NULL != (ret = get_path_from_PATH (current_pd->binary_name))) )
482     return ret;
483   if (NULL != (ret = get_path_from_proc_exe ()))
484     return ret;
485 #endif
486 #if WINDOWS
487   if (NULL != (ret = get_path_from_module_filename ()))
488     return ret;
489 #endif
490 #if DARWIN
491   if (NULL != (ret = get_path_from_dyld_image ()))
492     return ret;
493   if (NULL != (ret = get_path_from_NSGetExecutablePath ()))
494     return ret;
495 #endif
496   if ( (NULL != current_pd->binary_name) &&
497        (NULL != (ret = get_path_from_PATH (current_pd->binary_name))) )
498     return ret;
499   /* other attempts here */
500   LOG (GNUNET_ERROR_TYPE_ERROR,
501        _("Could not determine installation path for %s.  Set `%s' environment variable.\n"),
502        current_pd->project_dirname,
503        current_pd->env_varname);
504   return NULL;
505 }
506
507
508 /**
509  * @brief get the path to current app's bin/
510  * @return a pointer to the executable path, or NULL on error
511  */
512 static char *
513 os_get_exec_path ()
514 {
515   char *ret = NULL;
516
517 #if LINUX
518   if (NULL != (ret = get_path_from_proc_exe ()))
519     return ret;
520 #endif
521 #if WINDOWS
522   if (NULL != (ret = get_path_from_module_filename ()))
523     return ret;
524 #endif
525 #if DARWIN
526   if (NULL != (ret = get_path_from_NSGetExecutablePath ()))
527     return ret;
528 #endif
529   /* other attempts here */
530   return ret;
531 }
532
533
534 /**
535  * @brief get the path to a specific GNUnet installation directory or,
536  * with #GNUNET_OS_IPK_SELF_PREFIX, the current running apps installation directory
537  * @return a pointer to the dir path (to be freed by the caller)
538  */
539 char *
540 GNUNET_OS_installation_get_path (enum GNUNET_OS_InstallationPathKind dirkind)
541 {
542   size_t n;
543   char *dirname;
544   char *execpath = NULL;
545   char *tmp;
546   char *multiarch;
547   char *libdir;
548   int isbasedir;
549
550   /* if wanted, try to get the current app's bin/ */
551   if (dirkind == GNUNET_OS_IPK_SELF_PREFIX)
552     execpath = os_get_exec_path ();
553
554   /* try to get GNUnet's bin/ or lib/, or if previous was unsuccessful some
555    * guess for the current app */
556   if (NULL == execpath)
557     execpath = os_get_gnunet_path ();
558
559   if (NULL == execpath)
560     return NULL;
561
562   n = strlen (execpath);
563   if (0 == n)
564   {
565     /* should never happen, but better safe than sorry */
566     GNUNET_free (execpath);
567     return NULL;
568   }
569   /* remove filename itself */
570   while ((n > 1) && (DIR_SEPARATOR == execpath[n - 1]))
571     execpath[--n] = '\0';
572
573   isbasedir = 1;
574   if ((n > 6) &&
575       ((0 == strcasecmp (&execpath[n - 6], "/lib32")) ||
576        (0 == strcasecmp (&execpath[n - 6], "/lib64"))))
577   {
578     if ( (GNUNET_OS_IPK_LIBDIR != dirkind) &&
579          (GNUNET_OS_IPK_LIBEXECDIR != dirkind) )
580     {
581       /* strip '/lib32' or '/lib64' */
582       execpath[n - 6] = '\0';
583       n -= 6;
584     }
585     else
586       isbasedir = 0;
587   }
588   else if ((n > 4) &&
589            ((0 == strcasecmp (&execpath[n - 4], "/bin")) ||
590             (0 == strcasecmp (&execpath[n - 4], "/lib"))))
591   {
592     /* strip '/bin' or '/lib' */
593     execpath[n - 4] = '\0';
594     n -= 4;
595   }
596   multiarch = NULL;
597   if (NULL != (libdir = strstr (execpath, "/lib/")))
598   {
599     /* test for multi-arch path of the form "PREFIX/lib/MULTIARCH/";
600        here we need to re-add 'multiarch' to lib and libexec paths later! */
601     multiarch = &libdir[5];
602     if (NULL == strchr (multiarch, '/'))
603       libdir[0] = '\0'; /* Debian multiarch format, cut of from 'execpath' but preserve in multicarch */
604     else
605       multiarch = NULL; /* maybe not, multiarch still has a '/', which is not OK */
606   }
607   /* in case this was a directory named foo-bin, remove "foo-" */
608   while ((n > 1) && (execpath[n - 1] == DIR_SEPARATOR))
609     execpath[--n] = '\0';
610   switch (dirkind)
611   {
612   case GNUNET_OS_IPK_PREFIX:
613   case GNUNET_OS_IPK_SELF_PREFIX:
614     dirname = GNUNET_strdup (DIR_SEPARATOR_STR);
615     break;
616   case GNUNET_OS_IPK_BINDIR:
617     dirname = GNUNET_strdup (DIR_SEPARATOR_STR "bin" DIR_SEPARATOR_STR);
618     break;
619   case GNUNET_OS_IPK_LIBDIR:
620     if (isbasedir)
621     {
622       GNUNET_asprintf (&tmp,
623                        "%s%s%s%s%s%s%s",
624                        execpath,
625                        DIR_SEPARATOR_STR "lib",
626                        (NULL != multiarch) ? DIR_SEPARATOR_STR : "",
627                        (NULL != multiarch) ? multiarch : "",
628                        DIR_SEPARATOR_STR,
629                        current_pd->project_dirname,
630                        DIR_SEPARATOR_STR);
631       if (GNUNET_YES ==
632           GNUNET_DISK_directory_test (tmp, GNUNET_YES))
633       {
634         GNUNET_free (execpath);
635         return tmp;
636       }
637       GNUNET_free (tmp);
638       tmp = NULL;
639       dirname = NULL;
640       if (4 == sizeof (void *))
641       {
642         GNUNET_asprintf (&dirname,
643                          DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
644                          current_pd->project_dirname);
645         GNUNET_asprintf (&tmp,
646                          "%s%s",
647                          execpath,
648                          dirname);
649       }
650       if (8 == sizeof (void *))
651       {
652         GNUNET_asprintf (&dirname,
653                          DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
654                          current_pd->project_dirname);
655         GNUNET_asprintf (&tmp,
656                          "%s%s",
657                          execpath,
658                          dirname);
659       }
660
661       if ( (NULL != tmp) &&
662            (GNUNET_YES ==
663             GNUNET_DISK_directory_test (tmp, GNUNET_YES)) )
664       {
665         GNUNET_free (execpath);
666         GNUNET_free_non_null (dirname);
667         return tmp;
668       }
669       GNUNET_free (tmp);
670       GNUNET_free_non_null (dirname);
671     }
672     GNUNET_asprintf (&dirname,
673                      DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
674                      current_pd->project_dirname);
675     break;
676   case GNUNET_OS_IPK_DATADIR:
677     GNUNET_asprintf (&dirname,
678                      DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
679                      current_pd->project_dirname);
680     break;
681   case GNUNET_OS_IPK_LOCALEDIR:
682     dirname = GNUNET_strdup (DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "locale" DIR_SEPARATOR_STR);
683     break;
684   case GNUNET_OS_IPK_ICONDIR:
685     dirname = GNUNET_strdup (DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "icons" DIR_SEPARATOR_STR);
686     break;
687   case GNUNET_OS_IPK_DOCDIR:
688     GNUNET_asprintf (&dirname,
689                      DIR_SEPARATOR_STR "share" DIR_SEPARATOR_STR "doc" DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR,
690                      current_pd->project_dirname);
691     break;
692   case GNUNET_OS_IPK_LIBEXECDIR:
693     if (isbasedir)
694     {
695       GNUNET_asprintf (&dirname,
696                        DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR "libexec" DIR_SEPARATOR_STR,
697                        current_pd->project_dirname);
698       GNUNET_asprintf (&tmp,
699                        "%s%s%s%s",
700                        execpath,
701                        DIR_SEPARATOR_STR "lib" DIR_SEPARATOR_STR,
702                        (NULL != multiarch) ? multiarch : "",
703                        dirname);
704       if (GNUNET_YES ==
705           GNUNET_DISK_directory_test (tmp, GNUNET_YES))
706       {
707         GNUNET_free (execpath);
708         GNUNET_free (dirname);
709         return tmp;
710       }
711       GNUNET_free (tmp);
712       tmp = NULL;
713       dirname = NULL;
714       if (4 == sizeof (void *))
715       {
716         GNUNET_asprintf (&dirname,
717                          DIR_SEPARATOR_STR "lib32" DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR "libexec" DIR_SEPARATOR_STR,
718                          current_pd->project_dirname);
719         GNUNET_asprintf (&tmp,
720                          "%s%s",
721                          execpath,
722                          dirname);
723       }
724       if (8 == sizeof (void *))
725       {
726         GNUNET_asprintf (&dirname,
727                          DIR_SEPARATOR_STR "lib64" DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR "libexec" DIR_SEPARATOR_STR,
728                          current_pd->project_dirname);
729         GNUNET_asprintf (&tmp,
730                          "%s%s",
731                          execpath,
732                          dirname);
733       }
734       if ( (NULL != tmp) &&
735            (GNUNET_YES ==
736             GNUNET_DISK_directory_test (tmp, GNUNET_YES)) )
737       {
738         GNUNET_free (execpath);
739         GNUNET_free_non_null (dirname);
740         return tmp;
741       }
742       GNUNET_free (tmp);
743       GNUNET_free_non_null (dirname);
744     }
745     GNUNET_asprintf (&dirname,
746                      DIR_SEPARATOR_STR "%s" DIR_SEPARATOR_STR "libexec" DIR_SEPARATOR_STR,
747                      current_pd->project_dirname);
748     break;
749   default:
750     GNUNET_free (execpath);
751     return NULL;
752   }
753   GNUNET_asprintf (&tmp,
754                    "%s%s",
755                    execpath,
756                    dirname);
757   GNUNET_free (dirname);
758   GNUNET_free (execpath);
759   return tmp;
760 }
761
762
763 /**
764  * Given the name of a gnunet-helper, gnunet-service or gnunet-daemon
765  * binary, try to prefix it with the libexec/-directory to get the
766  * full path.
767  *
768  * @param progname name of the binary
769  * @return full path to the binary, if possible, otherwise copy of 'progname'
770  */
771 char *
772 GNUNET_OS_get_libexec_binary_path (const char *progname)
773 {
774   static char *cache;
775   char *libexecdir;
776   char *binary;
777
778   if ( (DIR_SEPARATOR == progname[0]) ||
779        (GNUNET_YES ==
780         GNUNET_STRINGS_path_is_absolute (progname,
781                                          GNUNET_NO,
782                                          NULL, NULL)) )
783     return GNUNET_strdup (progname);
784   if (NULL != cache)
785     libexecdir = cache;
786   else
787     libexecdir = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_LIBEXECDIR);
788   if (NULL == libexecdir)
789     return GNUNET_strdup (progname);
790   GNUNET_asprintf (&binary,
791                    "%s%s",
792                    libexecdir,
793                    progname);
794   cache = libexecdir;
795   return binary;
796 }
797
798
799 /**
800  * Check whether an executable exists and possibly if the suid bit is
801  * set on the file.  Attempts to find the file using the current PATH
802  * environment variable as a search path.
803  *
804  * @param binary the name of the file to check.
805  *        W32: must not have an .exe suffix.
806  * @param check_suid input true if the binary should be checked for SUID (*nix)
807  *        W32: checks if the program has sufficient privileges by executing this
808  *             binary with the -d flag. -d omits a programs main loop and only
809  *             executes all privileged operations in an binary.
810  * @param params parameters used for w32 privilege checking (can be NULL for != w32 )
811  * @return #GNUNET_YES if the file is SUID (*nix) or can be executed with current privileges (W32),
812  *         #GNUNET_NO if not SUID (but binary exists),
813  *         #GNUNET_SYSERR on error (no such binary or not executable)
814  */
815 int
816 GNUNET_OS_check_helper_binary (const char *binary,
817                                int check_suid,
818                                const char *params)
819 {
820   struct stat statbuf;
821   char *p;
822   char *pf;
823 #ifdef MINGW
824   char *binaryexe;
825
826   GNUNET_asprintf (&binaryexe,
827                    "%s.exe",
828                    binary);
829   if ( (GNUNET_YES ==
830         GNUNET_STRINGS_path_is_absolute (binaryexe,
831                                          GNUNET_NO,
832                                          NULL, NULL)) ||
833        (0 == strncmp (binary, "./", 2)) )
834     p = GNUNET_strdup (binaryexe);
835   else
836   {
837     p = get_path_from_PATH (binaryexe);
838     if (NULL != p)
839     {
840       GNUNET_asprintf (&pf, "%s/%s", p, binaryexe);
841       GNUNET_free (p);
842       p = pf;
843     }
844   }
845   GNUNET_free (binaryexe);
846 #else
847   if ( (GNUNET_YES ==
848         GNUNET_STRINGS_path_is_absolute (binary,
849                                          GNUNET_NO,
850                                          NULL,
851                                          NULL)) ||
852        (0 == strncmp (binary, "./", 2)) )
853   {
854     p = GNUNET_strdup (binary);
855   }
856   else
857   {
858     p = get_path_from_PATH (binary);
859     if (NULL != p)
860     {
861       GNUNET_asprintf (&pf,
862                        "%s/%s",
863                        p,
864                        binary);
865       GNUNET_free (p);
866       p = pf;
867     }
868   }
869 #endif
870   if (NULL == p)
871   {
872     LOG (GNUNET_ERROR_TYPE_INFO,
873          _("Could not find binary `%s' in PATH!\n"),
874          binary);
875     return GNUNET_SYSERR;
876   }
877   if (0 != ACCESS (p,
878                    X_OK))
879   {
880     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
881                        "access",
882                        p);
883     GNUNET_free (p);
884     return GNUNET_SYSERR;
885   }
886 #ifndef MINGW
887   if (0 == getuid ())
888   {
889     /* as we run as root, we don't insist on SUID */
890     GNUNET_free (p);
891     return GNUNET_YES;
892   }
893 #endif
894   if (0 != STAT (p,
895                  &statbuf))
896   {
897     LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING,
898                        "stat",
899                        p);
900     GNUNET_free (p);
901     return GNUNET_SYSERR;
902   }
903   if (check_suid)
904   {
905 #ifndef MINGW
906     if ( (0 != (statbuf.st_mode & S_ISUID)) &&
907          (0 == statbuf.st_uid) )
908     {
909       GNUNET_free (p);
910       return GNUNET_YES;
911     }
912     GNUNET_log (GNUNET_ERROR_TYPE_INFO,
913                 _("Binary `%s' exists, but is not SUID\n"),
914                 p);
915     /* binary exists, but not SUID */
916 #else
917     STARTUPINFO start;
918     char parameters[512];
919     PROCESS_INFORMATION proc;
920     DWORD exit_value;
921
922     GNUNET_snprintf (parameters,
923                      sizeof (parameters),
924                      "-d %s", params);
925     memset (&start, 0, sizeof (start));
926     start.cb = sizeof (start);
927     memset (&proc, 0, sizeof (proc));
928
929
930     // Start the child process.
931     if ( ! (CreateProcess( p,   // current windows (2k3 and up can handle / instead of \ in paths))
932         parameters,           // execute dryrun/priviliege checking mode
933         NULL,           // Process handle not inheritable
934         NULL,           // Thread handle not inheritable
935         FALSE,          // Set handle inheritance to FALSE
936         CREATE_DEFAULT_ERROR_MODE, // No creation flags
937         NULL,           // Use parent's environment block
938         NULL,           // Use parent's starting directory
939         &start,            // Pointer to STARTUPINFO structure
940         &proc )           // Pointer to PROCESS_INFORMATION structure
941                                ))
942       {
943         LOG (GNUNET_ERROR_TYPE_ERROR,
944              _("CreateProcess failed for binary %s (%d).\n"),
945              p, GetLastError());
946         return GNUNET_SYSERR;
947     }
948
949     // Wait until child process exits.
950     WaitForSingleObject( proc.hProcess, INFINITE );
951
952     if ( ! GetExitCodeProcess (proc.hProcess, &exit_value)){
953         LOG (GNUNET_ERROR_TYPE_ERROR,
954              _("GetExitCodeProcess failed for binary %s (%d).\n"),
955              p, GetLastError() );
956         return GNUNET_SYSERR;
957       }
958     // Close process and thread handles.
959     CloseHandle( proc.hProcess );
960     CloseHandle( proc.hThread );
961
962     if (!exit_value)
963       return GNUNET_YES;
964 #endif
965     }
966   GNUNET_free (p);
967   return GNUNET_NO;
968 }
969
970
971 /* end of os_installation.c */