ruby-magic 0.0.1 → 0.4.0

data/ext/magic/functions.c

@@ -1,274 +1,352 @@
-/* :enddoc: */
-
-/*
- * functions.c
- *
- * Copyright 2013-2014 Krzysztof Wilczynski
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+#if defined(__cplusplus)
+extern "C" {
+#endif
 
 #include "functions.h"
 
-int suppress_error_output(void *data);
+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);
 
-int override_current_locale(void *data);
-int restore_current_locale(void *data);
-
-int
-suppress_error_output(void *data)
+inline int
+check_fd(int fd)
 {
-    int local_errno;
-    mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO;
-
-    save_t *s = data;
-    assert(s != NULL && "Must be a valid pointer to `save_t' type");
+	errno = 0;
+	if (fd < 0 || (fcntl(fd, F_GETFD) < 0 && errno == EBADF)) {
+		errno = EBADF;
+		return -EBADF;
+	}
 
-    s->data.file.old_fd = -1;
-    s->data.file.new_fd = -1;
-    s->status = -1;
+	return 0;
+}
 
-    fflush(stderr);
-    fgetpos(stderr, &s->data.file.position);
+static int
+safe_dup(int fd)
+{
+	int new_fd;
+	int local_errno;
+	int flags = F_DUPFD;
 
-    s->data.file.old_fd = dup(fileno(stderr));
-    if (s->data.file.old_fd < 0) {
-        local_errno = errno;
-        goto out;
-    }
+#if defined(HAVE_F_DUPFD_CLOEXEC)
+	flags = F_DUPFD_CLOEXEC;
+#endif
 
-    s->data.file.new_fd = open("/dev/null", O_WRONLY | O_APPEND, mode);
-    if (s->data.file.new_fd < 0) {
-        local_errno = errno;
+	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;
+}
 
-        if (dup2(s->data.file.old_fd, fileno(stderr)) < 0) {
-            local_errno = errno;
-            goto out;
-        }
+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
 
-        close(s->data.file.old_fd);
-        goto out;
-    }
+	return rv;
+}
 
-    if (dup2(s->data.file.new_fd, fileno(stderr)) < 0) {
-        local_errno = errno;
-        goto out;
-    }
+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;
+}
 
-    close(s->data.file.new_fd);
-    return 0;
+int
+override_error_output(void *data)
+{
+	int local_errno;
+	mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO;
+	save_t *s = data;
 
-out:
-    s->status = local_errno;
-    errno = s->status;
+#if defined(HAVE_O_CLOEXEC)
+	mode |= O_CLOEXEC;
+#endif
 
-    return -1;
+	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");
+	int local_errno;
+	save_t *s = data;
 
-    if (s->data.file.old_fd < 0 && s->status != 0) {
-        return -1;
-    }
+	assert(s != NULL && \
+	       "Must be a valid pointer to `save_t' type");
 
-    fflush(stderr);
+	if (s->file.old_fd < 0 && s->status != 0)
+		return -1;
 
-    if (dup2(s->data.file.old_fd, fileno(stderr)) < 0) {
-        local_errno = errno;
-        goto out;
-    }
+	fflush(stderr);
 
-    close(s->data.file.old_fd);
-    clearerr(stderr);
-    fsetpos(stderr, &s->data.file.position);
+	if (dup2(s->file.old_fd, fileno(stderr)) < 0) {
+		local_errno = errno;
+		goto error;
+	}
 
-    if (setvbuf(stderr, NULL, _IONBF, 0) != 0) {
-        local_errno = errno;
-        goto out;
-    }
+	safe_close(s->file.old_fd);
+	clearerr(stderr);
+	fsetpos(stderr, &s->file.position);
 
-    return 0;
+	if (setvbuf(stderr, NULL, _IONBF, 0) != 0) {
+		local_errno = errno;
+		goto error;
+	}
 
-out:
-    s->status = local_errno;
-    errno = s->status;
-
-    return -1;
+	return 0;
+error:
+	s->status = local_errno;
+	errno = s->status;
+	return -1;
 }
 
-int
-override_current_locale(void *data)
+inline magic_t
+magic_open_wrapper(int flags)
 {
-    char *current_locale = NULL;
-
-    save_t *s = data;
-    assert(s != NULL && "Must be a valid pointer to `save_t' type");
-
-    s->status = -1;
-    s->data.locale = NULL;
-
-    current_locale = setlocale(LC_ALL, NULL);
-    if (!current_locale) {
-        goto out;
-    }
-
-    s->data.locale = strndup(current_locale, strlen(current_locale));
-    if (!s->data.locale) {
-        goto out;
-    }
-
-    if (!setlocale(LC_ALL, "C")) {
-        goto out;
-    }
+	return magic_open(flags);
+}
 
-    assert(s->data.locale != NULL && "Must be a valid pointer to `char' type");
-    s->status = 0;
+inline void
+magic_close_wrapper(magic_t magic)
+{
+	magic_close(magic);
+}
 
-out:
-    return s->status;
+inline const char*
+magic_error_wrapper(magic_t magic)
+{
+	return magic_error(magic);
 }
 
-int
-restore_current_locale(void *data)
+inline int
+magic_errno_wrapper(magic_t magic)
 {
-    save_t *s = data;
-    assert(s != NULL && "Must be a valid pointer to `save_t' type");
+	return magic_errno(magic);
+}
 
-    if (!s->data.locale && s->status != 0) {
-        return -1;
-    }
+inline const char*
+magic_getpath_wrapper(void)
+{
+	/*
+	 * The second argument translates to same value as the
+	 * FILE_LOAD constant, which when used results in this
+	 * function calling the get_default_magic() internally.
+	 *
+	 * N.B. magic_getpath() also honors the "MAGIC"
+	 * environment variable."
+	 */
+	return magic_getpath(NULL, 0);
+}
 
-    if (!setlocale(LC_ALL, s->data.locale)) {
-        goto out;
-    }
+inline int
+magic_getparam_wrapper(magic_t magic, int parameter, void *value)
+{
+	return magic_getparam(magic, parameter, value);
+}
 
-    assert(s->data.locale != NULL && "Must be a valid pointer to `char' type");
-    free(s->data.locale);
+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;
+	}
 
-    return 0;
+	if (parameter == MAGIC_PARAM_BYTES_MAX)
+		return magic_setparam(magic, parameter, value);
 
-out:
-    s->data.locale = NULL;
-    s->status = -1;
+	if (*(const size_t *)value > USHRT_MAX) {
+		errno = EOVERFLOW;
+		return -EOVERFLOW;
+	}
 
-    return -1;
+	return magic_setparam(magic, parameter, value);
 }
 
-inline const char*
-magic_getpath_wrapper(void)
+inline int
+magic_getflags_wrapper(magic_t magic)
 {
-    return magic_getpath(NULL, 0);
+#if defined(HAVE_MAGIC_GETFLAGS)
+	return magic_getflags(magic);
+#else
+	UNUSED(magic);
+	errno = ENOSYS;
+	return -ENOSYS;
+#endif
 }
 
 inline int
-magic_setflags_wrapper(struct magic_set *ms, int flags)
+magic_setflags_wrapper(magic_t magic, int flags)
 {
-    if (flags < MAGIC_NONE || flags > MAGIC_NO_CHECK_BUILTIN) {
-        errno = EINVAL;
-        return -EINVAL;
-    }
+	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;
-    }
+	if (flags & MAGIC_PRESERVE_ATIME) {
+		errno = ENOSYS;
+		return -ENOSYS;
+	}
 #endif
 
-    return magic_setflags(ms, flags);
+	return magic_setflags(magic, flags);
 }
 
 inline int
-magic_load_wrapper(struct magic_set *ms, const char *magicfile, int flags)
+magic_load_wrapper(magic_t magic, const char *magic_file, int flags)
 {
-    int rv;
-
-    MAGIC_FUNCTION(magic_load, rv, flags, ms, magicfile);
-
-    return rv;
+	int rv;
+	MAGIC_FUNCTION(magic_load, rv, flags, magic, magic_file);
+	return rv;
 }
 
 inline int
-magic_compile_wrapper(struct magic_set *ms, const char *magicfile, int flags)
+magic_load_buffers_wrapper(magic_t magic, void **buffers, size_t *sizes, size_t count, int flags)
 {
-    int rv;
-
-    MAGIC_FUNCTION(magic_compile, rv, flags, ms, magicfile);
-
-    return rv;
+	int rv;
+	MAGIC_FUNCTION(magic_load_buffers, rv, flags, magic, buffers, sizes, count);
+	return rv;
 }
 
 inline int
-magic_check_wrapper(struct magic_set *ms, const char *magicfile, int flags)
+magic_compile_wrapper(magic_t magic, const char *magic_file, int flags)
 {
-    int rv;
-
-    MAGIC_FUNCTION(magic_check, rv, flags, ms, magicfile);
+	int rv;
+	MAGIC_FUNCTION(magic_compile, rv, flags, magic, magic_file);
+	return rv;
+}
 
-    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(struct magic_set *ms, const char* filename, int flags)
+magic_file_wrapper(magic_t magic, const char* filename, int flags)
 {
-    const char *cstring;
-
-    MAGIC_FUNCTION(magic_file, cstring, flags, ms, filename);
-
-    return cstring;
+	const char *cstring;
+	MAGIC_FUNCTION(magic_file, cstring, flags, magic, filename);
+	return cstring;
 }
 
 inline const char*
-magic_buffer_wrapper(struct magic_set *ms, const void *buffer, size_t size, int flags)
+magic_buffer_wrapper(magic_t magic, const void *buffer, size_t size, int flags)
 {
-    const char *cstring;
-
-    MAGIC_FUNCTION(magic_buffer, cstring, flags, ms, buffer, size);
-
-    return cstring;
+	const char *cstring;
+	MAGIC_FUNCTION(magic_buffer, cstring, flags, magic, buffer, size);
+	return cstring;
 }
 
 inline const char*
-magic_descriptor_wrapper(struct magic_set *ms, int fd, int flags)
+magic_descriptor_wrapper(magic_t magic, int fd, int flags)
 {
-    const char *cstring;
+	int local_errno;
+	const char *cstring;
+
+	if (check_fd(fd) < 0) {
+		local_errno = errno;
+		goto error;
+	}
 
-    MAGIC_FUNCTION(magic_descriptor, cstring, flags, ms, fd);
+	MAGIC_FUNCTION(magic_descriptor, cstring, flags, magic, fd);
+	return cstring;
 
-    return cstring;
+error:
+	errno = local_errno;
+	return NULL;
 }
 
 inline int
 magic_version_wrapper(void)
 {
-#if defined(HAVE_MAGIC_VERSION)
-    return magic_version();
-#else
-# if defined(HAVE_WARNING)
-#  warning "function `int magic_version(void)' not implemented"
-# else
-#  pragma message("function `int magic_version(void)' not implemented")
-# endif
-    errno = ENOSYS;
-    return -ENOSYS;
-#endif
+	return magic_version();
 }
 
-/* vim: set ts=8 sw=4 sts=2 et : */
+#if defined(__cplusplus)
+}
+#endif