| /* GStreamer |
| * Copyright (C) 2004 Thomas Vander Stichele <thomas@apestaart.org> |
| * |
| * gst-run.c: tool to launch GStreamer tools with correct major/minor |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| * Boston, MA 02111-1307, USA. |
| */ |
| |
| #ifdef HAVE_CONFIG_H |
| # include "config.h" |
| #endif |
| |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <errno.h> |
| #include <glib.h> |
| |
| /* global statics for option parsing */ |
| static gboolean _print = FALSE; |
| static gchar *_arg_mm = NULL; |
| static gboolean _arg_list_mm = FALSE; |
| |
| /* popt options table for the wrapper */ |
| static GOptionEntry wrapper_options[] = { |
| {"print", 'p', 0, G_OPTION_ARG_NONE, &_print, |
| "print wrapped command line options", NULL}, |
| {"gst-mm", 0, 0, G_OPTION_ARG_STRING, &_arg_mm, |
| "Force major/minor version", "VERSION"}, |
| {"gst-list-mm", 0, 0, G_OPTION_ARG_NONE, &_arg_list_mm, |
| "List found major/minor versions", NULL}, |
| {NULL} |
| }; |
| |
| /* print out the major/minor, which is the hash key */ |
| static void |
| hash_print_key (gchar * key, gchar * value) |
| { |
| g_print ("%s\n", (gchar *) key); |
| } |
| |
| /* return value like strcmp, but compares major/minor numerically */ |
| static gint |
| compare_major_minor (const gchar * first, const gchar * second) |
| { |
| gchar **firsts, **seconds; |
| gint fmaj, fmin, smaj, smin; |
| gint ret = 0; |
| |
| firsts = g_strsplit (first, ".", 0); |
| seconds = g_strsplit (second, ".", 0); |
| |
| if (firsts[0] == NULL || firsts[1] == NULL) { |
| ret = -1; |
| goto beach; |
| } |
| if (seconds[0] == NULL || seconds[1] == NULL) { |
| ret = 1; |
| goto beach; |
| } |
| |
| fmaj = atoi (firsts[0]); |
| fmin = atoi (firsts[1]); |
| smaj = atoi (seconds[0]); |
| smin = atoi (seconds[1]); |
| |
| if (fmaj < smaj) { |
| ret = -1; |
| goto beach; |
| } |
| if (fmaj > smaj) { |
| ret = 1; |
| goto beach; |
| } |
| |
| /* fmaj == smaj */ |
| if (fmin < smin) { |
| ret = -1; |
| goto beach; |
| } |
| if (fmin > smin) { |
| ret = 1; |
| goto beach; |
| } |
| ret = 0; |
| |
| beach: |
| g_strfreev (firsts); |
| g_strfreev (seconds); |
| return ret; |
| } |
| |
| static void |
| find_highest_version (gchar * key, gchar * value, gchar ** highest) |
| { |
| if (*highest == NULL) { |
| /* first value, so just set it */ |
| *highest = key; |
| } |
| if (compare_major_minor (key, *highest) > 0) |
| *highest = key; |
| } |
| |
| /* Libtool creates shell scripts named "base" that calls actual binaries as |
| * .libs/lt-base. If we detect this is a libtool script, unmangle so we |
| * find the right binaries */ |
| static void |
| unmangle_libtool (gchar ** dir, gchar ** base) |
| { |
| gchar *new_dir, *new_base; |
| |
| if (!*dir) |
| return; |
| if (!*base) |
| return; |
| |
| /* we assume libtool when base starts with lt- and dir ends with .libs */ |
| if (!g_str_has_prefix (*base, "lt-")) |
| return; |
| if (!g_str_has_suffix (*dir, ".libs")) |
| return; |
| |
| new_base = g_strdup (&((*base)[3])); |
| new_dir = g_path_get_dirname (*dir); |
| g_free (*base); |
| g_free (*dir); |
| *base = new_base; |
| *dir = new_dir; |
| } |
| |
| /* Returns a directory path that contains the binary given as an argument. |
| * If the binary given contains a path, it gets looked for in that path. |
| * If it doesn't contain a path, it gets looked for in the standard path. |
| * |
| * The returned string is newly allocated. |
| */ |
| gchar * |
| get_dir_of_binary (const gchar * binary) |
| { |
| gchar *base, *dir; |
| gchar *full; |
| |
| base = g_path_get_basename (binary); |
| dir = g_path_get_dirname (binary); |
| |
| /* if putting these two together yields the same as binary, |
| * then we have the right breakup. If not, it's because no path was |
| * specified which caused get_basename to return "." */ |
| full = g_build_filename (dir, base, NULL); |
| |
| if (strcmp (full, binary) != 0) { |
| if (strcmp (dir, ".") != 0) { |
| g_warning ("This should not happen, g_path_get_dirname () has changed."); |
| g_free (base); |
| g_free (dir); |
| g_free (full); |
| return NULL; |
| } |
| |
| /* we know no path was specified, so search standard path for binary */ |
| g_free (full); |
| full = g_find_program_in_path (base); |
| if (!full) { |
| g_warning ("This should not happen, %s not in standard path.", base); |
| g_free (base); |
| g_free (dir); |
| return NULL; |
| } |
| } |
| |
| g_free (base); |
| g_free (dir); |
| dir = g_path_get_dirname (full); |
| g_free (full); |
| |
| return dir; |
| } |
| |
| /* Search the given directory for candidate binaries matching the base binary. |
| * Return a GHashTable of major/minor -> directory pairs |
| */ |
| GHashTable * |
| get_candidates (const gchar * dir, const gchar * base) |
| { |
| GDir *gdir; |
| GError *error = NULL; |
| const gchar *entry; |
| gchar *path; |
| gchar *suffix, *copy; |
| |
| gchar *pattern; |
| GPatternSpec *spec, *specexe; |
| |
| gchar **dirs; |
| gchar **cur; |
| |
| GHashTable *candidates = NULL; |
| |
| candidates = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); |
| |
| /* compile our pattern specs */ |
| pattern = g_strdup_printf ("%s-*.*", base); |
| spec = g_pattern_spec_new (pattern); |
| g_free (pattern); |
| pattern = g_strdup_printf ("%s-*.*.exe", base); |
| specexe = g_pattern_spec_new (pattern); |
| g_free (pattern); |
| |
| /* get all dirs from the path and prepend with given dir */ |
| if (dir) |
| path = g_strdup_printf ("%s%c%s", |
| dir, G_SEARCHPATH_SEPARATOR, g_getenv ("PATH")); |
| else |
| path = (gchar *) g_getenv ("PATH"); |
| dirs = g_strsplit (path, G_SEARCHPATH_SEPARATOR_S, 0); |
| if (dir) |
| g_free (path); |
| |
| /* check all of these in reverse order by winding to bottom and going up */ |
| cur = &dirs[0]; |
| while (*cur) |
| ++cur; |
| |
| while (cur != &dirs[0]) { |
| --cur; |
| if (!g_file_test (*cur, G_FILE_TEST_EXISTS) || |
| !g_file_test (*cur, G_FILE_TEST_IS_DIR)) { |
| continue; |
| } |
| |
| gdir = g_dir_open (*cur, 0, &error); |
| if (!gdir) { |
| g_warning ("Could not open dir %s: %s", *cur, error->message); |
| g_error_free (error); |
| return NULL; |
| } |
| while ((entry = g_dir_read_name (gdir))) { |
| if (g_pattern_match_string (spec, entry) |
| || g_pattern_match_string (specexe, entry)) { |
| gchar *full; |
| |
| /* is it executable ? */ |
| full = g_build_filename (*cur, entry, NULL); |
| if (!g_file_test (full, G_FILE_TEST_IS_EXECUTABLE)) { |
| g_free (full); |
| continue; |
| } |
| g_free (full); |
| |
| /* strip base and dash from it */ |
| suffix = g_strdup (&(entry[strlen (base) + 1])); |
| copy = g_strdup (suffix); |
| |
| /* strip possible .exe from copy */ |
| if (g_strrstr (copy, ".exe")) |
| g_strrstr (copy, ".exe")[0] = '\0'; |
| |
| /* stricter pattern check: check if it only contains digits or dots */ |
| g_strcanon (copy, "0123456789.", 'X'); |
| if (strstr (copy, "X")) { |
| g_free (suffix); |
| g_free (copy); |
| continue; |
| } |
| g_free (copy); |
| g_hash_table_insert (candidates, suffix, g_strdup (*cur)); |
| } |
| } |
| } |
| |
| g_strfreev (dirs); |
| g_pattern_spec_free (spec); |
| return candidates; |
| } |
| |
| int |
| main (int argc, char **argv) |
| { |
| GHashTable *candidates; |
| gchar *dir; |
| gchar *base; |
| gchar *highest = NULL; |
| gchar *binary; /* actual binary we're going to run */ |
| gchar *path = NULL; /* and its path */ |
| gchar *desc; |
| GOptionContext *ctx; |
| GError *err = NULL; |
| |
| /* detect stuff */ |
| dir = get_dir_of_binary (argv[0]); |
| base = g_path_get_basename (argv[0]); |
| |
| /* parse command line options */ |
| desc = g_strdup_printf ("wrapper to call versioned %s", base); |
| ctx = g_option_context_new (desc); |
| g_free (desc); |
| g_option_context_set_ignore_unknown_options (ctx, TRUE); |
| g_option_context_add_main_entries (ctx, wrapper_options, GETTEXT_PACKAGE); |
| if (!g_option_context_parse (ctx, &argc, &argv, &err)) { |
| g_print ("Error initializing: %s\n", err->message); |
| exit (1); |
| } |
| g_option_context_free (ctx); |
| |
| /* unmangle libtool if necessary */ |
| unmangle_libtool (&dir, &base); |
| |
| /* get all candidate binaries */ |
| candidates = get_candidates (dir, base); |
| g_free (dir); |
| |
| if (_arg_mm) { |
| /* if a version was forced, look it up in the hash table */ |
| dir = g_hash_table_lookup (candidates, _arg_mm); |
| if (!dir) { |
| g_print ("ERROR: Major/minor %s of tool %s not found.\n", _arg_mm, base); |
| return 1; |
| } |
| binary = g_strdup_printf ("%s-%s", base, _arg_mm); |
| } else { |
| highest = NULL; |
| |
| /* otherwise, just look up the highest version */ |
| if (candidates) { |
| g_hash_table_foreach (candidates, (GHFunc) find_highest_version, |
| &highest); |
| } |
| |
| if (highest == NULL) { |
| g_print ("ERROR: No version of tool %s found.\n", base); |
| return 1; |
| } |
| dir = g_hash_table_lookup (candidates, highest); |
| binary = g_strdup_printf ("%s-%s", base, highest); |
| } |
| |
| g_free (base); |
| |
| path = g_build_filename (dir, binary, NULL); |
| g_free (binary); |
| |
| /* print out list of major/minors we found if asked for */ |
| /* FIXME: do them in order by creating a GList of keys and sort them */ |
| if (_arg_list_mm) { |
| g_hash_table_foreach (candidates, (GHFunc) hash_print_key, NULL); |
| g_hash_table_destroy (candidates); |
| return 0; |
| } |
| |
| /* print out command line if asked for */ |
| argv[0] = path; |
| if (_print) { |
| int i; |
| |
| for (i = 0; i < argc; ++i) { |
| g_print ("%s", argv[i]); |
| if (i < argc - 1) |
| g_print (" "); |
| } |
| g_print ("\n"); |
| } |
| |
| /* execute */ |
| if (execv (path, argv) == -1) { |
| g_warning ("Error executing %s: %s (%d)", path, g_strerror (errno), errno); |
| } |
| g_free (path); |
| |
| return 0; |
| } |