cyrus-sasl: Paths relocate

mingw-w64-cyrus-sasl/19-paths-relocation.patch

@@ -0,0 +1,746 @@
+diff -Naur cyrus-sasl-2.1.26-orig/config/varexpand.m4 cyrus-sasl-2.1.26/config/varexpand.m4
+--- cyrus-sasl-2.1.26-orig/config/varexpand.m4	1970-01-01 03:00:00.000000000 +0300
++++ cyrus-sasl-2.1.26/config/varexpand.m4	2014-12-16 00:22:11.487600000 +0300
+@@ -0,0 +1,8 @@
++AC_DEFUN([FULL_EXPAND_VARIABLE], [
++  $1=$2
++  $1=`(
++       test "x$prefix" = xNONE && prefix="$ac_default_prefix"
++       test "x$exec_prefix" = xNONE && exec_prefix="${prefix}"
++       eval echo \""[$]$1"\"
++      )`
++])
+diff -Naur cyrus-sasl-2.1.26-orig/configure.in cyrus-sasl-2.1.26/configure.in
+--- cyrus-sasl-2.1.26-orig/configure.in	2014-12-15 23:10:23.125400000 +0300
++++ cyrus-sasl-2.1.26/configure.in	2014-12-16 00:23:05.167200000 +0300
+@@ -1027,6 +1027,8 @@
+   configdir=$plugindir:/etc/sasl2)
+ AC_DEFINE_UNQUOTED(CONFIGDIR, "$configdir", [Runtime config file location])
+ AC_SUBST(configdir)
++FULL_EXPAND_VARIABLE(sasl_bindir, "$bindir")
++AC_DEFINE_UNQUOTED(BINDIR, "$sasl_bindir", [Runtime executables location])
+ 
+ dnl look for rc4 libraries. we accept the CMU one or one from openSSL
+ AC_ARG_WITH(rc4, [  --with-rc4              use internal rc4 routines [[yes]] ],
+diff -Naur cyrus-sasl-2.1.26-orig/include/sasl.h cyrus-sasl-2.1.26/include/sasl.h
+--- cyrus-sasl-2.1.26-orig/include/sasl.h	2014-12-15 23:10:22.454600000 +0300
++++ cyrus-sasl-2.1.26/include/sasl.h	2014-12-15 23:43:10.374600000 +0300
+@@ -667,6 +667,8 @@
+ #define SASL_PATH_TYPE_PLUGIN	0
+ #define SASL_PATH_TYPE_CONFIG	1
+ 
++LIBSASL_API char * sasl_path_relocation(const char *from, const char *to);
++LIBSASL_API char * sasl_pathlist_relocation(const char *from_path, const char *to_path_list);
+ /* a simpler way to set plugin path or configuration file path
+  * without the need to set sasl_getpath_t callback.
+  *
+diff -Naur cyrus-sasl-2.1.26-orig/lib/common.c cyrus-sasl-2.1.26/lib/common.c
+--- cyrus-sasl-2.1.26-orig/lib/common.c	2014-12-15 23:10:22.953800000 +0300
++++ cyrus-sasl-2.1.26/lib/common.c	2014-12-15 23:46:29.514400000 +0300
+@@ -59,6 +59,7 @@
+ #include <saslutil.h>
+ #include <saslplug.h>
+ #include "saslint.h"
++#include "pathtools.h"
+ 
+ #ifdef HAVE_UNISTD_H
+ #include <unistd.h>
+@@ -86,6 +87,45 @@
+ #endif
+ 
+ 
++char *
++sasl_path_relocation(const char *from, const char *to)
++{
++#if defined(__MINGW32__)
++  char exe_path[PATH_MAX];
++  get_executable_path (NULL, &exe_path[0], sizeof(exe_path)/sizeof(exe_path[0]));
++  if (strrchr (exe_path, '/') != NULL)
++  {
++     strrchr (exe_path, '/')[1] = '\0';
++  }
++  char * rel_to_datadir = get_relative_path (from, to);
++  strcat (exe_path, rel_to_datadir);
++  simplify_path (&exe_path[0]);
++  return malloc_copy_string(exe_path);
++#else
++  return malloc_copy_string(to);
++#endif
++}
++
++char *
++sasl_pathlist_relocation(const char *from_path, const char *to_path_list)
++{
++#if defined(__MINGW32__)
++  static char stored_path[PATH_MAX];
++  static int stored = 0;
++  if (stored == 0)
++  {
++    char const * relocated = get_relocated_path_list(from_path, to_path_list);
++    strncpy (stored_path, relocated, PATH_MAX);
++    stored_path[PATH_MAX-1] = '\0';
++    free ((void *)relocated);
++    stored = 1;
++  }
++  return stored_path;
++#else
++  return (to_path_list);
++#endif
++}
++
+ static const char build_ident[] = "$Build: libsasl " PACKAGE "-" VERSION " $";
+ 
+ /* It turns out to be convenient to have a shared sasl_utils_t */
+@@ -1585,9 +1625,13 @@
+ 
+ #if defined(WIN32)
+         /* NB: On Windows platforms this value is always allocated */
++#  ifdef __MINGW32__
++        default_plugin_path = sasl_path_relocation(BINDIR, PLUGINDIR);
++#  else
+         default_plugin_path = _sasl_get_default_win_path(context,
+                                                          SASL_PLUGIN_PATH_ATTR,
+                                                          PLUGINDIR);
++#  endif
+ #else
+         /* NB: On Unix platforms this value is never allocated */
+         path = _sasl_get_default_unix_path(context,
+@@ -1640,9 +1684,13 @@
+ 
+ #if defined(WIN32)
+         /* NB: On Windows platforms this value is always allocated */
++#  ifdef __MINGW32__
++        default_plugin_path = sasl_pathlist_relocation(BINDIR, CONFIGDIR);
++#  else
+         default_conf_path = _sasl_get_default_win_path(context,
+                                                        SASL_CONF_PATH_ATTR,
+                                                        CONFIGDIR);
++#  endif
+ #else
+         /* NB: On Unix platforms this value is never allocated */
+         path = _sasl_get_default_unix_path(context,
+diff -Naur cyrus-sasl-2.1.26-orig/lib/Makefile.am cyrus-sasl-2.1.26/lib/Makefile.am
+--- cyrus-sasl-2.1.26-orig/lib/Makefile.am	2014-12-15 23:10:23.094200000 +0300
++++ cyrus-sasl-2.1.26/lib/Makefile.am	2014-12-15 23:24:10.600800000 +0300
+@@ -60,8 +60,8 @@
+ DLOPEN_C = dlopen.c
+ endif
+ 
+-common_headers = saslint.h
+-common_sources = auxprop.c canonusr.c checkpw.c client.c common.c config.c external.c md5.c saslutil.c server.c seterror.c $(DLOPEN_C) ../plugins/plugin_common.c
++common_headers = saslint.h pathtools.h
++common_sources = auxprop.c canonusr.c checkpw.c client.c common.c config.c external.c md5.c pathtools.c saslutil.c server.c seterror.c $(DLOPEN_C) ../plugins/plugin_common.c
+ 
+ LTLIBOBJS = @LTLIBOBJS@
+ LIBOBJS = @LIBOBJS@
+diff -Naur cyrus-sasl-2.1.26-orig/lib/pathtools.c cyrus-sasl-2.1.26/lib/pathtools.c
+--- cyrus-sasl-2.1.26-orig/lib/pathtools.c	1970-01-01 03:00:00.000000000 +0300
++++ cyrus-sasl-2.1.26/lib/pathtools.c	1970-01-01 03:00:00.000000000 +0300
+@@ -0,0 +1,538 @@
++/*
++      .Some useful path tools.
++        .ASCII only for now.
++   .Written by Ray Donnelly in 2014.
++   .Licensed under CC0 (and anything.
++  .else you need to license it under).
++      .No warranties whatsoever.
++  .email: <mingw.android@gmail.com>.
++ */
++
++#if defined(__APPLE__)
++#include <stdlib.h>
++#else
++#include <malloc.h>
++#endif
++#include <limits.h>
++#include <stdio.h>
++#include <string.h>
++#if defined(__linux__) || defined(__CYGWIN__) || defined(__MSYS__)
++#include <alloca.h>
++#endif
++#include <unistd.h>
++
++/* If you don't define this, then get_executable_path()
++   can only use argv[0] which will often not work well */
++#define IMPLEMENT_SYS_GET_EXECUTABLE_PATH
++
++#if defined(IMPLEMENT_SYS_GET_EXECUTABLE_PATH)
++#if defined(__linux__) || defined(__CYGWIN__) || defined(__MSYS__)
++/* Nothing needed, unistd.h is enough. */
++#elif defined(__APPLE__)
++#include <mach-o/dyld.h>
++#elif defined(_WIN32)
++#define WIN32_MEAN_AND_LEAN
++#include <windows.h>
++#include <psapi.h>
++#endif
++#endif /* defined(IMPLEMENT_SYS_GET_EXECUTABLE_PATH) */
++
++#include "pathtools.h"
++
++char *
++malloc_copy_string(char const * original)
++{
++  char * result = (char *) malloc (sizeof (char*) * strlen (original)+1);
++  if (result != NULL)
++  {
++    strcpy (result, original);
++  }
++  return result;
++}
++
++void
++sanitise_path(char * path)
++{
++  size_t path_size = strlen (path);
++
++  /* Replace any '\' with '/' */
++  char * path_p = path;
++  while ((path_p = strchr (path_p, '\\')) != NULL)
++  {
++    *path_p = '/';
++  }
++  /* Replace any '//' with '/' */
++  path_p = path;
++  while ((path_p = strstr (path_p, "//")) != NULL)
++  {
++    memmove (path_p, path_p + 1, path_size--);
++  }
++  return;
++}
++
++char *
++get_relative_path(char const * from_in, char const * to_in)
++{
++  size_t from_size = (from_in == NULL) ? 0 : strlen (from_in);
++  size_t to_size = (to_in == NULL) ? 0 : strlen (to_in);
++  size_t max_size = (from_size + to_size) * 2 + 4;
++  char * scratch_space = (char *) alloca (from_size + 1 + to_size + 1 + max_size + max_size);
++  char * from;
++  char * to;
++  char * common_part;
++  char * result;
++  size_t count;
++
++  /* No to, return "./" */
++  if (to_in == NULL)
++  {
++    return malloc_copy_string ("./");
++  }
++
++  /* If alloca failed or no from was given return a copy of to */
++  if (   from_in == NULL
++      || scratch_space == NULL )
++  {
++    return malloc_copy_string (to_in);
++  }
++
++  from = scratch_space;
++  strcpy (from, from_in);
++  to = from + from_size + 1;
++  strcpy (to, to_in);
++  common_part = to + to_size + 1;
++  result = common_part + max_size;
++  simplify_path (from);
++  simplify_path (to);
++
++  result[0] = '\0';
++
++  size_t match_size_dirsep = 0;  /* The match size up to the last /. Always wind back to this - 1 */
++  size_t match_size = 0;         /* The running (and final) match size. */
++  size_t largest_size = (from_size > to_size) ? from_size : to_size;
++  int to_final_is_slash = (to[to_size-1] == '/') ? 1 : 0;
++  char from_c;
++  char to_c;
++  for (match_size = 0; match_size < largest_size; ++match_size)
++  {
++    /* To simplify the logic, always pretend the strings end with '/' */
++    from_c = (match_size < from_size) ? from[match_size] : '/';
++    to_c =   (match_size <   to_size) ?   to[match_size] : '/';
++
++    if (from_c != to_c)
++    {
++      if (from_c != '\0' || to_c != '\0')
++      {
++        match_size = match_size_dirsep;
++      }
++      break;
++    }
++    else if (from_c == '/')
++    {
++      match_size_dirsep = match_size;
++    }
++  }
++  strncpy (common_part, from, match_size);
++  common_part[match_size] = '\0';
++  from += match_size;
++  to += match_size;
++  size_t ndotdots = 0;
++  char const* from_last = from + strlen(from) - 1;
++  while ((from = strchr (from, '/')) && from != from_last)
++  {
++    ++ndotdots;
++    ++from;
++  }
++  for (count = 0; count < ndotdots; ++count)
++  {
++    strcat(result, "../");
++  }
++  if (strlen(to) > 0)
++  {
++    strcat(result, to+1);
++  }
++  /* Make sure that if to ends with '/' result does the same, and
++     vice-versa. */
++  size_t size_result = strlen(result);
++  if ((to_final_is_slash == 1)
++      && (!size_result || result[size_result-1] != '/'))
++  {
++    strcat (result, "/");
++  }
++  else if (!to_final_is_slash
++           && size_result && result[size_result-1] == '/')
++  {
++    result[size_result-1] = '\0';
++  }
++
++  return malloc_copy_string (result);
++}
++
++void
++simplify_path(char * path)
++{
++  ssize_t n_toks = 1; /* in-case we need an empty initial token. */
++  ssize_t i, j;
++  size_t tok_size;
++  size_t in_size = strlen (path);
++  int it_ended_with_a_slash = (path[in_size - 1] == '/') ? 1 : 0;
++  char * result = path;
++  sanitise_path(result);
++  char * result_p = result;
++
++  do
++  {
++    ++n_toks;
++    ++result_p;
++  } while ((result_p = strchr (result_p, '/')) != NULL);
++
++  result_p = result;
++  char const ** toks = (char const **) alloca (sizeof (char const*) * n_toks);
++  n_toks = 0;
++  do
++  {
++    if (result_p > result)
++    {
++      *result_p++ = '\0';
++    }
++    else if (*result_p == '/')
++    {
++      /* A leading / creates an empty initial token. */
++      toks[n_toks++] = result_p;
++      *result_p++ = '\0';
++    }
++    toks[n_toks++] = result_p;
++  } while ((result_p = strchr (result_p, '/')) != NULL);
++
++  /* Remove all non-leading '.' and any '..' we can match
++     with an earlier forward path (i.e. neither '.' nor '..') */
++  for (i = 1; i < n_toks; ++i)
++  {
++    int removals[2] = { -1, -1 };
++    if ( strcmp (toks[i], "." ) == 0)
++    {
++      removals[0] = i;
++    }
++    else if ( strcmp (toks[i], ".." ) == 0)
++    {
++      /* Search backwards for a forward path to collapse.
++         If none are found then the .. also stays. */
++      for (j = i - 1; j > -1; --j)
++      {
++        if ( strcmp (toks[j], "." )
++          && strcmp (toks[j], ".." ) )
++        {
++          removals[0] = j;
++          removals[1] = i;
++          break;
++        }
++      }
++    }
++    for (j = 0; j < 2; ++j)
++    {
++      if (removals[j] >= 0) /* Can become -2 */
++      {
++        --n_toks;
++        memmove (&toks[removals[j]], &toks[removals[j]+1], (n_toks - removals[j])*sizeof (char*));
++        --i;
++        if (!j)
++        {
++          --removals[1];
++        }
++      }
++    }
++  }
++  result_p = result;
++  for (i = 0; i < n_toks; ++i)
++  {
++    tok_size = strlen(toks[i]);
++    memcpy (result_p, toks[i], tok_size);
++    result_p += tok_size;
++    if ((!i || tok_size) && ((i < n_toks - 1) || it_ended_with_a_slash == 1))
++    {
++      *result_p = '/';
++      ++result_p;
++    }
++  }
++  *result_p = '\0';
++}
++
++/* Returns actual_to by calculating the relative path from -> to and
++   applying that to actual_from. An assumption that actual_from is a
++   dir is made, and it may or may not end with a '/' */
++char const *
++get_relocated_path (char const * from, char const * to, char const * actual_from)
++{
++  char const * relative_from_to = get_relative_path (from, to);
++  char * actual_to = (char *) malloc (strlen(actual_from) + 2 + strlen(relative_from_to));
++  return actual_to;
++}
++
++int
++get_executable_path(char const * argv0, char * result, ssize_t max_size)
++{
++  char * system_result = (char *) alloca (max_size);
++  ssize_t system_result_size = -1;
++  ssize_t result_size = -1;
++
++  if (system_result != NULL)
++  {
++#if defined(IMPLEMENT_SYS_GET_EXECUTABLE_PATH)
++#if defined(__linux__) || defined(__CYGWIN__) || defined(__MSYS__)
++    system_result_size = readlink("/proc/self/exe", system_result, max_size);
++#elif defined(__APPLE__)
++    uint32_t bufsize = (uint32_t)max_size;
++    if (_NSGetExecutablePath(system_result, &bufsize) == 0)
++    {
++      system_result_size = (ssize_t)bufsize;
++    }
++#elif defined(_WIN32)
++    unsigned long bufsize = (unsigned long)max_size;
++    system_result_size = GetModuleFileNameA(NULL, system_result, bufsize);
++    if (system_result_size == 0 || system_result_size == (ssize_t)bufsize)
++    {
++      /* Error, possibly not enough space. */
++      system_result_size = -1;
++    }
++    else
++    {
++      /* Early conversion to unix slashes instead of more changes
++         everywhere else .. */
++      char * winslash;
++      system_result[system_result_size] = '\0';
++      while ((winslash = strchr (system_result, '\\')) != NULL)
++      {
++        *winslash = '/';
++      }
++    }
++#else
++#warning "Don't know how to get executable path on this system"
++#endif
++#endif /* defined(IMPLEMENT_SYS_GET_EXECUTABLE_PATH) */
++  }
++  /* Use argv0 as a default in-case of failure */
++  if (system_result_size != -1)
++  {
++    strncpy (result, system_result, system_result_size);
++    result[system_result_size] = '\0';
++  }
++  else
++  {
++    if (argv0 != NULL)
++    {
++      strncpy (result, argv0, max_size);
++      result[max_size-1] = '\0';
++    }
++    else
++    {
++      result[0] = '\0';
++    }
++  }
++  result_size = strlen (result);
++  return result_size;
++}
++
++char const *
++strip_n_prefix_folders(char const * path, size_t n)
++{
++  if (path == NULL)
++  {
++    return NULL;
++  }
++
++  if (path[0] != '/')
++  {
++    return path;
++  }
++
++  char const * last = path;
++  while (n-- && path != NULL)
++  {
++    last = path;
++    path = strchr (path + 1, '/');
++  }
++  return (path == NULL) ? last : path;
++}
++
++void
++strip_n_suffix_folders(char * path, size_t n)
++{
++  if (path == NULL)
++  {
++    return;
++  }
++  while (n--)
++  {
++    if (strrchr (path + 1, '/'))
++    {
++      *strrchr (path + 1, '/') = '\0';
++    }
++    else
++    {
++      return;
++    }
++  }
++  return;
++}
++
++size_t
++split_path_list(char const * path_list, char split_char, char *** arr)
++{
++  size_t path_count;
++  size_t path_list_size;
++  char const * path_list_p;
++
++  path_list_p = path_list;
++  if (path_list == NULL || path_list[0] == '\0')
++  {
++    return 0;
++  }
++  path_list_size = strlen (path_list);
++
++  path_count = 0;
++  do
++  {
++    ++path_count;
++    ++path_list_p;
++  }
++  while ((path_list_p = strchr (path_list_p, split_char)) != NULL);
++
++  /* allocate everything in one go. */
++  char * all_memory = (char *) malloc (sizeof (char *) * path_count + strlen(path_list) + 1);
++  if (all_memory == NULL)
++    return 0;
++  *arr = (char **)all_memory;
++  all_memory += sizeof (char *) * path_count;
++
++  path_count = 0;
++  path_list_p = path_list;
++  char const * next_path_list_p = 0;
++  do
++  {
++    next_path_list_p = strchr (path_list_p, split_char);
++    if (next_path_list_p != NULL)
++    {
++      ++next_path_list_p;
++    }
++    size_t this_size = (next_path_list_p != NULL)
++                       ? next_path_list_p - path_list_p - 1
++                       : &path_list[path_list_size] - path_list_p;
++    memcpy (all_memory, path_list_p, this_size);
++    all_memory[this_size] = '\0';
++    (*arr)[path_count++] = all_memory;
++    all_memory += this_size + 1;
++  } while ((path_list_p = next_path_list_p) != NULL);
++
++  return path_count;
++}
++
++char *
++get_relocated_path_list(char const * from, char const * to_path_list)
++{
++  char exe_path[MAX_PATH];
++  char * temp;
++  get_executable_path (NULL, &exe_path[0], sizeof (exe_path) / sizeof (exe_path[0]));
++  if ((temp = strrchr (exe_path, '/')) != NULL)
++  {
++    temp[1] = '\0';
++  }
++
++  char **arr = NULL;
++  /* Ask Alexey why he added this. Are we not 100% sure
++     that we're dealing with unix paths here? */
++  char split_char = ':';
++  if (strchr (to_path_list, ';'))
++  {
++    split_char = ';';
++  }
++  size_t count = split_path_list (to_path_list, split_char, &arr);
++  int result_size = 1 + (count - 1); /* count - 1 is for ; delim. */
++  size_t exe_path_size = strlen (exe_path);
++  size_t i;
++  /* Space required is:
++     count * (exe_path_size + strlen (rel_to_datadir))
++     rel_to_datadir upper bound is:
++     (count * strlen (from)) + (3 * num_slashes (from))
++     + strlen(arr[i]) + 1.
++     .. pathalogically num_slashes (from) is strlen (from)
++     (from = ////////) */
++  size_t space_required = (count * (exe_path_size + 4 * strlen (from))) + count - 1;
++  for (i = 0; i < count; ++i)
++  {
++    space_required += strlen (arr[i]);
++  }
++  char * scratch = (char *) alloca (space_required);
++  if (scratch == NULL)
++    return NULL;
++  for (i = 0; i < count; ++i)
++  {
++    char * rel_to_datadir = get_relative_path (from, arr[i]);
++    scratch[0] = '\0';
++    arr[i] = scratch;
++    strcat (scratch, exe_path);
++    strcat (scratch, rel_to_datadir);
++    simplify_path (arr[i]);
++    size_t arr_i_size = strlen (arr[i]);
++    result_size += arr_i_size;
++    scratch = arr[i] + arr_i_size + 1;
++  }
++  char * result = (char *) malloc (result_size);
++  if (result == NULL)
++  {
++    return NULL;
++  }
++  result[0] = '\0';
++  for (i = 0; i < count; ++i)
++  {
++    strcat (result, arr[i]);
++    if (i != count-1)
++    {
++#if defined(_WIN32)
++      strcat (result, ";");
++#else
++      strcat (result, ":");
++#endif
++    }
++  }
++  free ((void*)arr);
++  return result;
++}
++
++char *
++single_path_relocation(const char *from, const char *to)
++{
++#if defined(__MINGW32__)
++  char exe_path[PATH_MAX];
++  get_executable_path (NULL, &exe_path[0], sizeof(exe_path)/sizeof(exe_path[0]));
++  if (strrchr (exe_path, '/') != NULL)
++  {
++     strrchr (exe_path, '/')[1] = '\0';
++  }
++  char * rel_to_datadir = get_relative_path (from, to);
++  strcat (exe_path, rel_to_datadir);
++  simplify_path (&exe_path[0]);
++  return malloc_copy_string(exe_path);
++#else
++  return malloc_copy_string(to);
++#endif
++}
++
++char *
++pathlist_relocation(const char *from_path, const char *to_path_list)
++{
++#if defined(__MINGW32__)
++  static char stored_path[PATH_MAX];
++  static int stored = 0;
++  if (stored == 0)
++  {
++    char const * relocated = get_relocated_path_list(from_path, to_path_list);
++    strncpy (stored_path, relocated, PATH_MAX);
++    stored_path[PATH_MAX-1] = '\0';
++    free ((void *)relocated);
++    stored = 1;
++  }
++  return stored_path;
++#else
++  return (to_path_list);
++#endif
++}
+diff -Naur cyrus-sasl-2.1.26-orig/lib/pathtools.h cyrus-sasl-2.1.26/lib/pathtools.h
+--- cyrus-sasl-2.1.26-orig/lib/pathtools.h	1970-01-01 03:00:00.000000000 +0300
++++ cyrus-sasl-2.1.26/lib/pathtools.h	1970-01-01 03:00:00.000000000 +0300
+@@ -0,0 +1,53 @@
++/*
++      .Some useful path tools.
++        .ASCII only for now.
++   .Written by Ray Donnelly in 2014.
++   .Licensed under CC0 (and anything.
++  .else you need to license it under).
++      .No warranties whatsoever.
++  .email: <mingw.android@gmail.com>.
++ */
++
++#ifndef PATHTOOLS_H
++#define PATHTOOLS_H
++
++#include <unistd.h>
++#if defined(__APPLE__)
++#include <stdlib.h>
++#else
++#include <malloc.h>
++#endif
++#include <stdio.h>
++
++char * malloc_copy_string(char const * original);
++
++/* In-place replaces any '\' with '/' and any '//' with '/' */
++void sanitise_path(char * path);
++
++/* Uses a host OS specific function to determine the path of the executable,
++   if IMPLEMENT_SYS_GET_EXECUTABLE_PATH is defined, otherwise uses argv0. */
++int get_executable_path(char const * argv0, char * result, ssize_t max_size);
++
++/* Where possible, in-place removes occourances of '.' and 'path/..' */
++void simplify_path(char * path);
++
++/* Allocates (via malloc) and returns the path to get from from to to. */
++char * get_relative_path(char const * from, char const * to);
++
++size_t split_path_list(char const * path_list, char split_char, char *** arr);
++
++/* Advances path along by the amount that removes n prefix folders. */
++char const *
++strip_n_prefix_folders(char const * path, size_t n);
++
++/* NULL terminates path to remove n suffix folders. */
++void
++strip_n_suffix_folders(char * path, size_t n);
++
++char const * get_relocated_path (char const * from, char const * to, char const * actual_from);
++char * get_relocated_path_list(char const * from, char const * to_path_list);
++
++char * single_path_relocation(const char *from, const char *to);
++char * pathlist_relocation(const char *from_path, const char *to_path_list);
++
++#endif /* PATHTOOLS_H */
+diff -Naur cyrus-sasl-2.1.26-orig/utils/pluginviewer.c cyrus-sasl-2.1.26/utils/pluginviewer.c
+--- cyrus-sasl-2.1.26-orig/utils/pluginviewer.c	2014-12-15 23:10:22.407800000 +0300
++++ cyrus-sasl-2.1.26/utils/pluginviewer.c	2014-12-15 23:45:36.037600000 +0300
+@@ -201,7 +201,7 @@
+     if (searchpath) {
+         *path = searchpath;
+     } else {
+-        *path = PLUGINDIR;
++        *path = sasl_path_relocation(BINDIR, PLUGINDIR);
+     }
+ 
+     return SASL_OK;

mingw-w64-cyrus-sasl/PKGBUILD

@@ -23,7 +23,7 @@
 _realname=cyrus-sasl
 pkgname=("${MINGW_PACKAGE_PREFIX}-${_realname}")
 pkgver=2.1.26
-pkgrel=1
+pkgrel=2
 pkgdesc="Cyrus Simple Authentication Service Layer (SASL) library"
 arch=('any')
 url="http://cyrusimap.web.cmu.edu/"
@@ -43,14 +43,14 @@ source=(http://cyrusimap.org/releases/${_realname}-${pkgver}.tar.gz
         08-cyrus-sasl-2.1.26-size_t.patch
         09-cyrus-sasl-2.1.26-msys2.patch
         10-MinGW-w64-already-has-getopt.patch
-        11-MinGW-w64-add-disable-win32-reg-option.patch
         12-MinGW-w64-uses-ws2_32-not-socket.patch
         13-MSYS2-Use-cp-f-instead-of-ln-s.patch
         14-MinGW-w64-add-LIBSASL_API-to-function-definitions.patch
         15-MinGW-w64-define-LIBSASL_EXPORTS_eq_1-for-sasldb.patch
         16-MinGW-w64-define-WIN32_LEAN_AND_MEAN-avoiding-handle_t-redef.patch
         17-MinGW-w64-define-S_IRUSR-and-S_IWUSR.patch
-        18-MinGW-w64-use-windlopen.c-not-dlopen.c.patch)
+        18-MinGW-w64-use-windlopen.c-not-dlopen.c.patch
+        19-paths-relocation.patch)
 md5sums=('a7f4e5e559a0e37b3ffc438c9456e425'
          '7f52862a74ada70ed2e257990f9b4334'
          'd7ff8a6d1902478190c705a580b4bd80'
@@ -62,14 +62,14 @@ md5sums=('a7f4e5e559a0e37b3ffc438c9456e425'
          'bcaafcbc79054e8356217213d6eda16d'
          'b48df2818c4836801445d9dee0adfaa0'
          '0804261cbd3605300de45d239f0985b1'
-         '88646a5b27f7d2d2dae2d37a84ce4bb9'
          '67b07a35ee220b0e604bfe232c73757b'
          'e22b151aceb15d15abf86827741ecd9e'
          '74deb3bb998a1da6e1b7697606269a44'
          '3255cf7f8bf21e26e1900b5df5050d86'
          '8a7b3c956b6ade7f50b322f2f2211a46'
          '42b8a2f0f6a9b8c88168a5e6a7433cbb'
-         'aa98b66f10b3628b3278e97adf4d4ce5')
+         'aa98b66f10b3628b3278e97adf4d4ce5'
+         'f0d91129bd6c0220a904cdb196aa3f4e')
 
 prepare() {
   cd ${srcdir}/$_realname-$pkgver
@@ -84,7 +84,6 @@ prepare() {
   patch -p1 -i ${srcdir}/08-cyrus-sasl-2.1.26-size_t.patch
   patch -p1 -i ${srcdir}/09-cyrus-sasl-2.1.26-msys2.patch
   patch -p1 -i ${srcdir}/10-MinGW-w64-already-has-getopt.patch
-  patch -p1 -i ${srcdir}/11-MinGW-w64-add-disable-win32-reg-option.patch
   patch -p1 -i ${srcdir}/12-MinGW-w64-uses-ws2_32-not-socket.patch
   patch -p1 -i ${srcdir}/13-MSYS2-Use-cp-f-instead-of-ln-s.patch
   patch -p1 -i ${srcdir}/14-MinGW-w64-add-LIBSASL_API-to-function-definitions.patch
@@ -92,6 +91,7 @@ prepare() {
   patch -p1 -i ${srcdir}/16-MinGW-w64-define-WIN32_LEAN_AND_MEAN-avoiding-handle_t-redef.patch
   patch -p1 -i ${srcdir}/17-MinGW-w64-define-S_IRUSR-and-S_IWUSR.patch
   patch -p1 -i ${srcdir}/18-MinGW-w64-use-windlopen.c-not-dlopen.c.patch
+  patch -p1 -i ${srcdir}/19-paths-relocation.patch
 
   sed 's/AM_CONFIG_HEADER/AC_CONFIG_HEADERS/' -i configure.in
   rm -f config/config.guess config/config.sub 
@@ -128,13 +128,13 @@ build() {
 
   ../$_realname-$pkgver/configure \
     --prefix=${MINGW_PREFIX} \
-    --build=$CHOST \
-    --host=$CHOST \
+    --build=${MINGW_CHOST} \
+    --host=${MINGW_CHOST} \
     --with-configdir=${MINGW_PREFIX}/etc/sasl2:${MINGW_PREFIX}/etc/sasl:${MINGW_PREFIX}/lib/sasl2 \
+    --with-plugindir=${MINGW_PREFIX}/lib/sasl2 \
     --disable-static --enable-shared \
     --with-sqlite3=${MINGW_PREFIX} \
     --disable-ldapdb \
-    --disable-win32-reg \
     --oldincludedir=${MINGW_PREFIX}/include \
     --without-saslauthd \
     --without-pwcheck \