ruby-magic-static 0.3.0

data/README.md

@@ -0,0 +1,46 @@
+# File Magic in Ruby
+
+This is a fork of https://github.com/kwilczynski/ruby-magic to compile a
+vendored copy of libmagic.
+
+[![Build Status](https://travis-ci.org/kwilczynski/ruby-magic.svg)](https://travis-ci.org/kwilczynski/ruby-magic)
+[![Documentation Status](https://inch-ci.org/github/kwilczynski/ruby-magic.svg)](https://inch-ci.org/github/kwilczynski/ruby-magic)
+[![Gem Version](https://badge.fury.io/rb/ruby-magic.svg)](http://badge.fury.io/rb/ruby-magic)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+## Introduction
+
+Provides simple interface to [libmagic][1] for Ruby Programming Language.
+
+## Table of Contents
+
+1. [Contributing](#contributing)
+2. [Versioning](#versioning)
+3. [Author](#author)
+4. [Copyright](#copyright)
+5. [License](#license)
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for best practices and instructions on
+setting up your development environment.
+
+## Versioning
+
+This project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+For the versions available, see the tags on this repository.
+
+## Author
+
+Krzysztof Wilczyński (<kw@linux.com>)
+
+## Copyright
+
+Copyright 2013-2021 Krzysztof Wilczyński
+
+## License
+
+This project is licensed under the terms of the Apache License, Version 2.0 license.   
+To view the full license see the included [LICENSE](LICENSE) file.
+
+[1]: https://en.wikipedia.org/wiki/File_(command)

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/ext/magic/common.h

@@ -0,0 +1,132 @@
+#if !defined(_COMMON_H)
+#define _COMMON_H 1
+
+#if !defined(_GNU_SOURCE)
+# define _GNU_SOURCE 1
+#endif
+
+#if !defined(_BSD_SOURCE)
+# define _BSD_SOURCE 1
+#endif
+
+#if !defined(_DEFAULT_SOURCE)
+# define _DEFAULT_SOURCE 1
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <assert.h>
+#include <sys/stat.h>
+#include <magic.h>
+#include <ruby.h>
+
+#if defined(HAVE_RUBY_IO_H)
+# include <ruby/io.h>
+#else
+# include <rubyio.h>
+#endif
+
+#if !defined(BIT)
+# define BIT(n) (1 << (n))
+#endif
+
+#if !defined(UNUSED)
+# define UNUSED(x) (void)(x)
+#endif
+
+#if defined(F_DUPFD_CLOEXEC)
+# define HAVE_F_DUPFD_CLOEXEC 1
+#endif
+
+#if defined(O_CLOEXEC)
+# define HAVE_O_CLOEXEC 1
+#endif
+
+#if defined(POSIX_CLOSE_RESTART)
+# define HAVE_POSIX_CLOSE_RESTART 1
+#endif
+
+#define MAGIC_EXTENSION_SEPARATOR "/"
+#define MAGIC_CONTINUE_SEPARATOR "\n- "
+
+#if !defined(MAGIC_NO_CHECK_CSV)
+# define MAGIC_NO_CHECK_CSV 0
+#endif
+
+#if !defined(MAGIC_NO_CHECK_JSON)
+# define MAGIC_NO_CHECK_JSON 0
+#endif
+
+#define DATA_P(x)    (RB_TYPE_P((x), T_DATA))
+#define BOOLEAN_P(x) (RB_TYPE_P((x), T_TRUE) || RB_TYPE_P((x), T_FALSE))
+#define STRING_P(x)  (RB_TYPE_P((x), T_STRING))
+#define ARRAY_P(x)   (RB_TYPE_P((x), T_ARRAY))
+#define FILE_P(x)    (RB_TYPE_P((x), T_FILE))
+
+#define RVAL2CBOOL(x) (RTEST(x))
+#define CBOOL2RVAL(x) ((x) ? Qtrue : Qfalse)
+
+#define RVAL2CSTR(x) (NIL_P(x) ? NULL : StringValueCStr(x))
+#define CSTR2RVAL(x) ((x) == NULL ? Qnil : rb_str_new2(x))
+
+#define RARRAY_EMPTY	  rb_ary_new()
+#define RARRAY_EMPTY_P(a) (RARRAY_LEN(a) == 0)
+#define RARRAY_FIRST(a)   (RARRAY_EMPTY_P(a) ? Qnil : rb_ary_entry((a), 0))
+
+#define CLASS_NAME(o) (NIL_P((o)) ? "nil" : rb_obj_classname((o)))
+
+#if !defined(T_INTEGER)
+# define T_INTEGER rb_cInteger
+#endif
+
+#if !defined(HAVE_RB_IO_T)
+# define rb_io_t OpenFile
+#endif
+
+#if !defined(GetReadFile)
+# define FPTR_TO_FD(p) ((p)->fd)
+#else
+# define FPTR_TO_FD(p) (fileno(GetReadFile(p)))
+#endif
+
+#define NOGVL_FUNCTION (VALUE (*)(void *))
+
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+    defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H
+# include <ruby/thread.h>
+# define NOGVL(f, d) \
+	rb_thread_call_without_gvl((f), (d), RUBY_UBF_IO, NULL)
+#elif defined(HAVE_RB_THREAD_BLOCKING_REGION)
+# define NOGVL(f, d) \
+	rb_thread_blocking_region(NOGVL_FUNCTION(f), (d), RUBY_UBF_IO, NULL)
+#else
+# include <rubysig.h>
+static inline VALUE
+fake_blocking_region(VALUE (*f)(ANYARGS), void *data)
+{
+	VALUE rv;
+
+	TRAP_BEG;
+	rv = f(data);
+	TRAP_END;
+
+	return rv;
+}
+# define NOGVL(f, d) \
+	fake_blocking_region(NOGVL_FUNCTION(f), (d))
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* _COMMON_H */

data/ext/magic/extconf.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'digest'
+require 'open-uri'
+
+LIBMAGIC_TAG = '5.39'.freeze
+
+workdir = Dir.pwd
+libdir = File.join(workdir, 'file-' + LIBMAGIC_TAG)
+gemdir = File.expand_path(File.join(__dir__, '../..'))
+gem_ext_dir = File.join(gemdir, 'lib', 'ext')
+gem_include_dir = File.join(gem_ext_dir, 'include')
+gem_lib_dir = File.join(gem_ext_dir, 'lib')
+build_lib_dir = File.join(libdir, 'src', '.libs')
+
+expected_sha256 = 'f05d286a76d9556243d0cb05814929c2ecf3a5ba07963f8f70bfaaa70517fad1'
+filename = "#{workdir}/file.tar.gz"
+
+unless File.exist?(filename)
+  File.open(filename, 'wb') do |target_file|
+    URI.open("ftp://ftp.astron.com/pub/file/file-#{LIBMAGIC_TAG}.tar.gz", 'rb') do |read_file|
+      target_file.write(read_file.read)
+    end
+  end
+
+  checksum = Digest::SHA256.hexdigest(File.read(filename))
+
+  if checksum != expected_sha256
+    raise "SHA256 of #{filename} does not match: got #{checksum}, expected #{expected_sha256}"
+  end
+end
+
+system("tar -xzf #{filename}") || raise('ERROR')
+system("cd #{libdir} && ./configure --prefix=#{gem_ext_dir} && make install") || raise('ERROR')
+
+$LOCAL_LIBS << '-lmagic'
+$LIBPATH << gem_lib_dir
+$CFLAGS << " -I #{libdir}/src"
+
+def darwin?
+  RbConfig::CONFIG['target_os'] =~ /darwin/
+end
+
+def windows?
+  RbConfig::CONFIG['target_os'] =~ /mswin|mingw32|windows/
+end
+
+if ENV['CC']
+  RbConfig::CONFIG['CC'] = RbConfig::MAKEFILE_CONFIG['CC'] = ENV['CC']
+end
+
+ENV['CC'] = RbConfig::CONFIG['CC']
+
+$CFLAGS += ' -std=c99 -fPIC'
+$CFLAGS += ' -Wall -Wextra -pedantic'
+
+if RbConfig::CONFIG['CC'] =~ /gcc/
+  $CFLAGS += ' -O3' unless $CFLAGS =~ /-O\d/
+  $CFLAGS += ' -Wcast-qual -Wwrite-strings -Wconversion -Wmissing-noreturn -Winline'
+end
+
+unless darwin?
+  $LDFLAGS += ' -Wl,--as-needed -Wl,--no-undefined'
+end
+
+if windows?
+  $LDFLAGS += ' -static-libgcc'
+end
+
+%w[
+  CFLAGS
+  CXXFLAGS
+  CPPFLAGS
+].each do |variable|
+  $CFLAGS += format(' %s', ENV[variable]) if ENV[variable]
+end
+
+$LDFLAGS += format(' %s', ENV['LDFLAGS']) if ENV['LDFLAGS']
+
+unless have_header('ruby.h')
+  abort "\n" + (<<-EOS).gsub(/^[ ]{,3}/, '') + "\n"
+    You appear to be missing Ruby development libraries and/or header
+    files. You can install missing compile-time dependencies in one of
+    the following ways:
+
+    - Debian / Ubuntu
+
+        apt-get install ruby-dev
+
+    - Red Hat / CentOS / Fedora
+
+        yum install ruby-devel or dnf install ruby-devel
+
+    - Mac OS X (Darwin)
+
+        brew install ruby (for Homebrew, see https://brew.sh)
+        port install ruby2.6 (for MacPorts, see https://www.macports.org)
+
+    - OpenBSD / NetBSD
+
+        pkg_add ruby (for pkgsrc, see https://www.pkgsrc.org)
+
+    - FreeBSD
+
+        pkg install ruby (for FreeBSD Ports, see https://www.freebsd.org/ports)
+
+    Alternatively, you can use either of the following Ruby version
+    managers in order to install Ruby locally (for your user only)
+    and/or system-wide:
+
+    - Ruby Version Manager (for RVM, see https://rvm.io)
+    - Ruby Environment (for rbenv, see https://github.com/sstephenson/rbenv)
+    - Change Ruby (for chruby, see https://github.com/postmodern/chruby)
+
+    More information about how to install Ruby on various platforms
+    available at the following web site:
+
+      https://www.ruby-lang.org/en/documentation/installation
+  EOS
+end
+
+have_library('ruby')
+
+have_func('rb_thread_call_without_gvl')
+have_func('rb_thread_blocking_region')
+
+unless have_header('magic.h')
+  abort "\n" + (<<-EOS).gsub(/^[ ]{,3}/, '') + "\n"
+    You appear to be missing libmagic(3) library and/or necessary header
+    files. You can install missing compile-time dependencies in one of
+    the following ways:
+
+    - Debian / Ubuntu
+
+        apt-get install libmagic-dev
+
+    - Red Hat / CentOS / Fedora
+
+        yum install file-devel or dns install file-devel
+
+    - Mac OS X (Darwin)
+
+        brew install libmagic (for Homebrew, see https://brew.sh)
+        port install libmagic (for MacPorts, see https://www.macports.org)
+
+    - OpenBSD / NetBSD
+
+        pkg_add file (for pkgsrc, see https://www.pkgsrc.org)
+
+    - FreeBSD
+
+        pkg install file (for FreeBSD Ports, see https://www.freebsd.org/ports)
+
+    Alternatively, you can download recent release of the file(1) package
+    from the following web site and attempt to compile libmagic(3) manually:
+
+      https://www.darwinsys.com/file
+  EOS
+end
+
+have_library('magic')
+
+unless have_func('magic_getpath')
+  abort "\n" + (<<-EOS).gsub(/^[ ]{,3}/, '') + "\n"
+    Your version of libmagic(3) appears to be too old.
+
+    Please, consider upgrading to at least version 5.29 or newer,
+    if possible. For more information about file(1) command and
+    libmagic(3) please visit the following web site:
+
+      https://www.darwinsys.com/file
+  EOS
+end
+
+have_func('magic_getflags')
+
+%w[
+  utime.h
+  sys/types.h
+  sys/time.h
+].each do |h|
+  have_header(h)
+end
+
+%w[
+  utime
+  utimes
+].each do |f|
+  have_func(f)
+end
+
+dir_config('magic', [gem_include_dir], [gem_lib_dir])
+
+create_header
+create_makefile('magic/magic')

data/ext/magic/functions.c

@@ -0,0 +1,344 @@
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#include "functions.h"
+
+int check_fd(int fd);
+static int safe_dup(int fd);
+static int safe_close(int fd);
+static int safe_cloexec(int fd);
+int override_error_output(void *data);
+int restore_error_output(void *data);
+
+inline int
+check_fd(int fd)
+{
+	errno = 0;
+	if (fd < 0 || (fcntl(fd, F_GETFD) < 0 && errno == EBADF)) {
+		errno = EBADF;
+		return -EBADF;
+	}
+
+	return 0;
+}
+
+static int
+safe_dup(int fd)
+{
+	int new_fd;
+	int local_errno;
+	int flags = F_DUPFD;
+
+#if defined(HAVE_F_DUPFD_CLOEXEC)
+	flags = F_DUPFD_CLOEXEC;
+#endif
+
+	new_fd = fcntl(fd, flags, fileno(stderr) + 1);
+	if (new_fd < 0 && errno == EINVAL) {
+		new_fd = dup(fd);
+		if (new_fd < 0) {
+			local_errno = errno;
+			goto error;
+		}
+	}
+	if (safe_cloexec(new_fd) < 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	return new_fd;
+error:
+	errno = local_errno;
+	return -1;
+}
+
+static int
+safe_close(int fd)
+{
+	int rv;
+#if defined(HAVE_POSIX_CLOSE_RESTART)
+	rv = posix_close(fd, 0);
+#else
+	rv = close(fd);
+	if (rv < 0 && errno == EINTR)
+		errno = EINPROGRESS;
+#endif
+
+	return rv;
+}
+
+static inline int
+safe_cloexec(int fd)
+{
+	int local_errno;
+	int flags = fcntl(fd, F_GETFD);
+
+	if (flags < 0) {
+		local_errno = errno;
+		goto error;
+	}
+	if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	return 0;
+error:
+	errno = local_errno;
+	return -1;
+}
+
+int
+override_error_output(void *data)
+{
+	int local_errno;
+	mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO;
+	save_t *s = data;
+
+#if defined(HAVE_O_CLOEXEC)
+	mode |= O_CLOEXEC;
+#endif
+
+	assert(s != NULL && \
+	       "Must be a valid pointer to `save_t' type");
+
+	s->file.old_fd = -1;
+	s->file.new_fd = -1;
+	s->status = -1;
+
+	fflush(stderr);
+	fgetpos(stderr, &s->file.position);
+
+	s->file.old_fd = safe_dup(fileno(stderr));
+	if (s->file.old_fd < 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	s->file.new_fd = open("/dev/null", O_WRONLY | O_APPEND, mode);
+	if (s->file.new_fd < 0) {
+		local_errno = errno;
+
+		if (dup2(s->file.old_fd, fileno(stderr)) < 0) {
+			local_errno = errno;
+			goto error;
+		}
+
+		safe_close(s->file.old_fd);
+		goto error;
+	}
+	if (safe_cloexec(s->file.new_fd) < 0) {
+		local_errno = errno;
+		goto error;
+	}
+	if (dup2(s->file.new_fd, fileno(stderr)) < 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	safe_close(s->file.new_fd);
+
+	return 0;
+error:
+	s->status = local_errno;
+	errno = s->status;
+	return -1;
+}
+
+int
+restore_error_output(void *data)
+{
+	int local_errno;
+	save_t *s = data;
+
+	assert(s != NULL && \
+	       "Must be a valid pointer to `save_t' type");
+
+	if (s->file.old_fd < 0 && s->status != 0)
+		return -1;
+
+	fflush(stderr);
+
+	if (dup2(s->file.old_fd, fileno(stderr)) < 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	safe_close(s->file.old_fd);
+	clearerr(stderr);
+	fsetpos(stderr, &s->file.position);
+
+	if (setvbuf(stderr, NULL, _IONBF, 0) != 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	return 0;
+error:
+	s->status = local_errno;
+	errno = s->status;
+	return -1;
+}
+
+inline magic_t
+magic_open_wrapper(int flags)
+{
+	return magic_open(flags);
+}
+
+inline void
+magic_close_wrapper(magic_t magic)
+{
+	magic_close(magic);
+}
+
+inline const char*
+magic_error_wrapper(magic_t magic)
+{
+	return magic_error(magic);
+}
+
+inline int
+magic_errno_wrapper(magic_t magic)
+{
+	return magic_errno(magic);
+}
+
+inline const char*
+magic_getpath_wrapper(void)
+{
+	return magic_getpath(NULL, 0);
+}
+
+inline int
+magic_getparam_wrapper(magic_t magic, int parameter, void *value)
+{
+	return magic_getparam(magic, parameter, value);
+}
+
+inline int
+magic_setparam_wrapper(magic_t magic, int parameter, const void *value)
+{
+	if (*(const int *)value < 0 || *(const size_t *)value > UINT_MAX) {
+		errno = EOVERFLOW;
+		return -EOVERFLOW;
+	}
+
+	if (parameter == MAGIC_PARAM_BYTES_MAX)
+		return magic_setparam(magic, parameter, value);
+
+	if (*(const size_t *)value > USHRT_MAX) {
+		errno = EOVERFLOW;
+		return -EOVERFLOW;
+	}
+
+	return magic_setparam(magic, parameter, value);
+}
+
+inline int
+magic_getflags_wrapper(magic_t magic)
+{
+#if defined(HAVE_MAGIC_GETFLAGS)
+	return magic_getflags(magic);
+#else
+	UNUSED(magic);
+	errno = ENOSYS;
+	return -ENOSYS;
+#endif
+}
+
+inline int
+magic_setflags_wrapper(magic_t magic, int flags)
+{
+	if (flags < 0 || flags > 0xfffffff) {
+		errno = EINVAL;
+		return -EINVAL;
+	}
+
+#if !defined(HAVE_UTIME) && !defined(HAVE_UTIMES)
+	if (flags & MAGIC_PRESERVE_ATIME) {
+		errno = ENOSYS;
+		return -ENOSYS;
+	}
+#endif
+
+	return magic_setflags(magic, flags);
+}
+
+inline int
+magic_load_wrapper(magic_t magic, const char *magic_file, int flags)
+{
+	int rv;
+	MAGIC_FUNCTION(magic_load, rv, flags, magic, magic_file);
+	return rv;
+}
+
+inline int
+magic_load_buffers_wrapper(magic_t magic, void **buffers, size_t *sizes, size_t count, int flags)
+{
+	int rv;
+	MAGIC_FUNCTION(magic_load_buffers, rv, flags, magic, buffers, sizes, count);
+	return rv;
+}
+
+inline int
+magic_compile_wrapper(magic_t magic, const char *magic_file, int flags)
+{
+	int rv;
+	MAGIC_FUNCTION(magic_compile, rv, flags, magic, magic_file);
+	return rv;
+}
+
+inline int
+magic_check_wrapper(magic_t magic, const char *magic_file, int flags)
+{
+	int rv;
+	MAGIC_FUNCTION(magic_check, rv, flags, magic, magic_file);
+	return rv;
+}
+
+inline const char*
+magic_file_wrapper(magic_t magic, const char* filename, int flags)
+{
+	const char *cstring;
+	MAGIC_FUNCTION(magic_file, cstring, flags, magic, filename);
+	return cstring;
+}
+
+inline const char*
+magic_buffer_wrapper(magic_t magic, const void *buffer, size_t size, int flags)
+{
+	const char *cstring;
+	MAGIC_FUNCTION(magic_buffer, cstring, flags, magic, buffer, size);
+	return cstring;
+}
+
+inline const char*
+magic_descriptor_wrapper(magic_t magic, int fd, int flags)
+{
+	int local_errno;
+	const char *cstring;
+
+	if (check_fd(fd) < 0) {
+		local_errno = errno;
+		goto error;
+	}
+
+	MAGIC_FUNCTION(magic_descriptor, cstring, flags, magic, fd);
+	return cstring;
+
+error:
+	errno = local_errno;
+	return NULL;
+}
+
+inline int
+magic_version_wrapper(void)
+{
+	return magic_version();
+}
+
+#if defined(__cplusplus)
+}
+#endif