repos/pEpEngine: src/platform_unix.c@c15b4ca2b52a

     1 // This file is under GNU General Public License 3.0

     2 // see LICENSE.txt

     4 #define _POSIX_C_SOURCE 200809L

     6 #ifdef ANDROID

     7 #ifndef __LP64__

     8 #include <time64.h>

     9 #endif

    10 #endif

    12 #include <time.h>

    13 #include <string.h>

    14 #include <stdlib.h>

    15 #include <assert.h>

    16 #include <sys/stat.h>

    17 #include <sys/types.h>

    18 #include <fcntl.h>

    19 #include <regex.h>

    21 #include "platform_unix.h"

    23 #define MAX_PATH 1024

    24 #ifndef LOCAL_DB_FILENAME

    25 #define LOCAL_DB_FILENAME ".pEp_management.db"

    26 #endif

    27 #define SYSTEM_DB_FILENAME "system.db"

    29 #ifndef bool

    30 #define bool int

    31 #define true 1

    32 #define false 0

    33 #endif

    35 #ifdef ANDROID

    36 #include <uuid.h>

    38 /* FIXME : timegm will miss when linking for x86_64 on android, when supported */

    39 #ifndef __LP64__

    40 time_t timegm(struct tm* const t) {

    41     static const time_t kTimeMax = ~(1L << (sizeof(time_t) * CHAR_BIT - 1));

    42     static const time_t kTimeMin = (1L << (sizeof(time_t) * CHAR_BIT - 1));

    43     time64_t result = timegm64(t);

    44     if (result < kTimeMin || result > kTimeMax)

    45         return -1;

    46     return result;

    47 }

    48 #endif

    50 char *stpncpy(char *dst, const char *src, size_t n)

    51 {

    52     if (n != 0) {

    53         char *d = dst;

    54         const char *s = src;

    56         dst = &dst[n];

    57         do {

    58             if ((*d++ = *s++) == 0) {

    59                 dst = d - 1;

    60                 /* NUL pad the remaining n-1 bytes */

    61                 while (--n != 0)

    62                     *d++ = 0;

    63                 break;

    64             }

    65         } while (--n != 0);

    66     }

    67     return (dst);

    68 }

    70 char *stpcpy(char *dst, const char *src)

    71 {

    72     for (;; ++dst, ++src) {

    73         *dst = *src;

    74         if (*dst == 0)

    75             break;

    76     }

    77     return dst;

    78 }

    80 /*

    81 long int random(void)

    82 {

    83     static bool seeded = false;

    84     static unsigned short xsubi[3];

    85     if(!seeded)

    86     {

    87         const long long t = (long long)time(NULL);

    88         xsubi[0] = (unsigned short)t;

    89         xsubi[1] = (unsigned short)(t>>16);

    90         xsubi[2] = (unsigned short)(t>>32);

    91         seeded = true;

    92     }

    94     return nrand48(xsubi);

    95 } */

    97 const char *android_system_db(void)

    98 {

    99     static char buffer[MAX_PATH];

   100     static bool done = false;

   102     if (!done) {

   103         char *tw_env;

   104         if(tw_env = getenv("TRUSTWORDS")){

   105             char *p = stpncpy(buffer, tw_env, MAX_PATH);

   106             ssize_t len = MAX_PATH - (p - buffer) - 2;

   108             if (len < strlen(SYSTEM_DB_FILENAME)) {

   109                 assert(0);

   110                 return NULL;

   111             }

   113             *p++ = '/';

   114             strncpy(p, SYSTEM_DB_FILENAME, len);

   115             done = true;

   116         }else{

   117             return NULL;

   118         }

   120     }

   121     return buffer;

   122 }

   125 void uuid_generate_random(pEpUUID out)

   126 {

   127     uuid_t *uuid;

   128     uuid_rc_t rc_create;

   129     size_t size = sizeof(uuid_string_t);

   130     void *_out = out;

   132     if ((rc_create = uuid_create(&uuid)) != UUID_RC_OK ||

   133         uuid_make(uuid, UUID_MAKE_V1) != UUID_RC_OK ||

   134         uuid_export(uuid, UUID_FMT_BIN, &_out, &size) != UUID_RC_OK)

   135     {

   136         memset(out, 0, sizeof(pEpUUID));

   137     }

   139     if (rc_create == UUID_RC_OK)

   140     {

   141         uuid_destroy(uuid);

   142     }

   143 }

   146 void uuid_unparse_upper(pEpUUID uu, uuid_string_t out)

   147 {

   148     uuid_t *uuid;

   149     uuid_rc_t rc_create;

   150     size_t size = sizeof(uuid_string_t);

   151     void *_out = out;

   153     if ((rc_create = uuid_create(&uuid)) != UUID_RC_OK ||

   154         uuid_import(uuid, UUID_FMT_BIN, uu, sizeof(pEpUUID)) != UUID_RC_OK ||

   155         uuid_export(uuid, UUID_FMT_STR, &_out, &size) != UUID_RC_OK)

   156     {

   157         memset(out, 0, sizeof(uuid_string_t));

   158     }

   159     else

   160     {

   161         out[sizeof(uuid_string_t) - 1] = 0;

   162     }

   164     if (rc_create == UUID_RC_OK)

   165     {

   166         uuid_destroy(uuid);

   167     }

   168 }

   170 #endif

   172 #if !defined(BSD) && !defined(__APPLE__)

   174 size_t strlcpy(char* dst, const	char* src, size_t size) {

   175     size_t retval = strlen(src);

   176     size_t size_to_copy = (retval < size ? retval : size - 1);

   178     // strlcpy doc says src and dst not allowed to overlap, as

   179     // it's undefined. So this is acceptable:

   180     memcpy((void*)dst, (void*)src, size_to_copy); // no defined error return, but strcpy doesn't either

   181     dst[size_to_copy] = '\0';

   182     return retval;

   183 }

   185 size_t strlcat(char* dst, const	char* src, size_t size) {

   186     size_t start_len = strnlen(dst, size);

   187     if (start_len == size)

   188         return size; // no copy, no null termination in size bytes, according to spec

   190     size_t add_len = strlen(src);

   191     size_t retval = start_len + add_len;

   192     size_t size_to_copy = (retval < size ? add_len : (size - start_len) - 1);

   194     // strlcat doc says src and dst not allowed to overlap, as

   195     // it's undefined. So this is acceptable:

   196     memcpy((void*)(dst + start_len), (void*)src, size_to_copy); // no defined error return, but strcpy doesn't either

   197     dst[start_len + size_to_copy] = '\0';

   198     return retval;

   199 }

   201 #ifdef USE_NETPGP

   202 // FIXME: This may cause problems - this is a quick compatibility fix for netpgp code

   203 int regnexec(const regex_t* preg, const char* string,

   204              size_t len, size_t nmatch, regmatch_t pmatch[], int eflags) {

   205     return regexec(preg, string, nmatch, pmatch, eflags);

   206 }

   207 #endif

   209 #endif

   211 #ifdef NDEBUG

   212 const char *unix_local_db(void)

   213 #else

   214 const char *unix_local_db(int reset)

   215 #endif

   216 {

   217     static char buffer[MAX_PATH];

   218     static bool done = false;

   220     #ifdef NDEBUG

   221     if (!done)

   222     #else

   223     if ((!done) || reset)

   224     #endif

   225     {

   226         char *home_env;

   227         if((home_env = getenv("HOME"))){

   228             char *p = stpncpy(buffer, home_env, MAX_PATH);

   229             ssize_t len = MAX_PATH - (p - buffer) - 2;

   231             if (len < strlen(LOCAL_DB_FILENAME)) {

   232                 assert(0);

   233                 return NULL;

   234             }

   236             *p++ = '/';

   237             strncpy(p, LOCAL_DB_FILENAME, len);

   238             done = true;

   239         }else{

   240             return NULL;

   241         }

   243     }

   244     return buffer;

   245 }

   247 static const char *gpg_conf_path = ".gnupg";

   248 static const char *gpg_conf_name = "gpg.conf";

   249 static const char *gpg_agent_conf_name = "gpg-agent.conf";

   250 static const char *gpg_conf_empty = "# Created by pEpEngine\n";

   252 #ifdef NDEBUG

   253 static bool ensure_gpg_home(const char **conf, const char **home){

   254 #else

   255 static bool ensure_gpg_home(const char **conf, const char **home, int reset){

   256 #endif

   257     static char path[MAX_PATH];

   258     static char dirname[MAX_PATH];

   259     static bool done = false;

   261 #ifdef NDEBUG

   262     if (!done) {

   263 #else

   264     if (reset || !done) {

   265 #endif

   266         char *p;

   267         ssize_t len;

   268         char *gpg_home_env = getenv("GNUPGHOME");

   269         char *home_env = getenv("HOME");

   271         if(gpg_home_env){

   273             p = stpncpy(path, gpg_home_env, MAX_PATH);

   274             len = MAX_PATH - (p - path) - 2;

   276             if (len < strlen(gpg_conf_name))

   277             {

   278                 assert(0);

   279                 return false;

   280             }

   282         }else if(home_env){

   284             p = stpncpy(path, home_env, MAX_PATH);

   285             len = MAX_PATH - (p - path) - 3;

   287             if (len < strlen(gpg_conf_path) + strlen(gpg_conf_name))

   288             {

   289                 assert(0);

   290                 return false;

   291             }

   293             *p++ = '/';

   294             strncpy(p, gpg_conf_path, len);

   295             p += strlen(gpg_conf_path);

   296             len -= strlen(gpg_conf_path) - 1;

   298         }else{

   300             assert(0);

   301             return false;

   302         }

   304         strncpy(dirname, path, MAX_PATH);

   305         *p++ = '/';

   306         strncpy(p, gpg_conf_name, len);

   308         if(access(path, F_OK)){

   309             int fd;

   310             if(access(dirname, F_OK )) {

   311                 mkdir(dirname, S_IRUSR | S_IWUSR | S_IXUSR);

   312             }

   314             fd = open(path, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);

   316             if(fd>0) {

   317                 ssize_t res;

   318                 len = strlen(gpg_conf_empty);

   319                 res = write(fd, gpg_conf_empty, len);

   320                 close(fd);

   321                 if(res < len) {

   322                     assert(0);

   323                     return false;

   324                 }

   325             }

   326         }

   328         done = true;

   329     }

   331     if(conf) *conf=path;

   332     if(home) *home=dirname;

   334     return true;

   335 }

   337 #ifdef NDEBUG

   338 static bool ensure_gpg_agent_conf(const char **agent_conf){

   339 #else

   340 static bool ensure_gpg_agent_conf(const char **agent_conf, int reset){

   341 #endif

   342     static char agent_path[MAX_PATH];

   343     static bool done = false;

   345 #ifdef NDEBUG

   346     if (!done) {

   347         const char *dirname;

   349         if (!ensure_gpg_home(NULL, &dirname)) /* Then dirname won't be set. */

   350             return false;

   351 #else

   352     if (reset || !done) {

   353         const char *dirname;

   355         if (!ensure_gpg_home(NULL, &dirname, reset)) /* Then dirname won't be set. */

   356             return false;

   357 #endif

   359         char *p = stpncpy(agent_path, dirname, MAX_PATH);

   361         ssize_t len = MAX_PATH - (p - agent_path) - 2;

   363         if (len < strlen(gpg_agent_conf_name))

   364         {

   365             assert(0);

   366             return false;

   367         }

   369         *p++ = '/';

   371         strncpy(p, gpg_agent_conf_name, len);

   373         if(access(agent_path, F_OK)){

   374             int fd;

   375             if(access(dirname, F_OK )) {

   376                 mkdir(dirname, S_IRUSR | S_IWUSR | S_IXUSR);

   377             }

   379             fd = open(agent_path, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);

   381             if(fd>0) {

   382                 ssize_t res;

   383                 len = strlen(gpg_conf_empty);

   384                 res = write(fd, gpg_conf_empty, len);

   385                 close(fd);

   386                 if(res < len) {

   387                     assert(0);

   388                     return false;

   389                 }

   390             }

   391         }

   392         done = true;

   393     }

   394     if(agent_conf) *agent_conf=agent_path;

   396     return true;

   397 }

   399 #ifdef NDEBUG

   400 const char *gpg_conf(void)

   401 {

   402     const char *conf;

   403     if(ensure_gpg_home(&conf, NULL))

   404         return conf;

   405     return NULL;

   406 }

   407 #else

   408 const char *gpg_conf(int reset)

   409 {

   410     const char *conf;

   411     if(ensure_gpg_home(&conf, NULL, reset))

   412         return conf;

   413     return NULL;

   414 }

   415 #endif

   417 #ifdef NDEBUG

   418 const char *gpg_home(void)

   419 {

   420     const char *home;

   421     if(ensure_gpg_home(NULL, &home))

   422         return home;

   423     return NULL;

   424 }

   425 #else

   426 const char *gpg_home(int reset)

   427 {

   428     const char *home;

   429     if(ensure_gpg_home(NULL, &home, reset))

   430         return home;

   431     return NULL;

   432 }

   433 #endif

   435 #ifdef NDEBUG

   436 const char *gpg_agent_conf(void)

   437 {

   438     const char *agent_conf;

   439     if(ensure_gpg_agent_conf(&agent_conf))

   440         return agent_conf;

   441     return NULL;

   442 }

   443 #else

   444 const char *gpg_agent_conf(int reset)

   445 {

   446     const char *agent_conf;

   447     if(ensure_gpg_agent_conf(&agent_conf, reset))

   448         return agent_conf;

   449     return NULL;

   450 }

   451 #endif

author	us@chu.huenfield.org
	Tue, 25 Dec 2018 14:46:45 +0100
branch	sync
changeset 3209	c15b4ca2b52a
parent 2748	a8db3d62c2fd
child 2755	65c6b4bb11a6
child 3638	4ba9bd8b80c1
child 3901	cdfe2dddb5da
permissions	-rw-r--r--