src/utils/lib/magiclib_stub.c

   1 /* File: magic.ml
   2
   3    Copyright (C) 2005
   4
   5      Christophe Troestler
   6      email: Christophe.Troestler@umh.ac.be
   7      WWW: http://www.umh.ac.be/math/an/software/
   8
   9    This library is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU Lesser General Public License
  11    version 2.1 as published by the Free Software Foundation, with the
  12    special exception on linking described in file LICENSE.
  13
  14    This library is distributed in the hope that it will be useful, but
  15    WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the file
  17    LICENSE for more details.
  18 */
  19 /*      $Id$     */
  20
  21 #include "../../../config/config.h"
  22 #include <caml/mlvalues.h>
  23 #include <caml/memory.h>
  24 #include <caml/alloc.h>
  25 #include <caml/custom.h>
  26 #include <caml/fail.h>
  27 #include <caml/callback.h>
  28
  29 #include <magic.h>
  30 #include <errno.h>
  31 #define _XOPEN_SOURCE 600
  32 #include <string.h>
  33 #include <stdio.h>
  34
  35 /* Outputs an error message and terminates the program. */
  36 #define DEBUG(...) \
  37   fprintf(stderr, "DEBUG magic_stub: " __VA_ARGS__);  \
  38   printf("\n")
  39
  40 #define CAML_MAGIC_VERSION "0.2"
  41
  42 /*
  43  * Failure
  44  */
  45
  46 static void raise_magic_failure(const char * msg)
  47 {
  48   static value * exn = NULL;
  49   if (exn == NULL) exn = caml_named_value("Magiclib.Failure");
  50   raise_with_string(*exn, (char *) msg);
  51 }
  52
  53 /* [fname] is the function name. */
  54 static void raise_on_error(const char* fname, magic_t cookie)
  55 {
  56   const char *err_magic;
  57   char *errmsg; /* For thread safety of error messages */
  58   int flen;
  59
  60   flen = strlen(fname);
  61   if ((err_magic = magic_error(cookie)) != NULL) {
  62     if ((errmsg = malloc(flen + strlen(err_magic) + 1)) == NULL)
  63       raise_out_of_memory();
  64     strcpy(errmsg, fname);
  65     strcpy(errmsg + flen, err_magic);
  66     raise_magic_failure(errmsg);
  67   }
  68   else {
  69     int len = 80;  /* Initial buffer length */
  70     int err;
  71
  72     /* Allocate buffer [errmsg] until there is enough space for the
  73      * error message. */
  74     err = magic_errno(cookie);
  75     if ((errmsg = malloc(len)) == NULL) raise_out_of_memory();
  76     strcpy(errmsg, fname);
  77 #ifdef HAVE_STRERROR_R
  78     while (strerror_r(err, errmsg + flen, len - flen) < 0) {
  79       len *= 2;
  80       errmsg = realloc(errmsg, len);
  81       if (errmsg == NULL) raise_out_of_memory();
  82     }
  83 #else
  84       strcat (errmsg, strerror(err));
  85 #endif
  86     raise_sys_error(copy_string(errmsg));
  87   }
  88 }
  89
  90
  91 /*
  92  * magic_t
  93  */
  94
  95 /* magic_t is a pointer on 'struct magic_set' so one can set it to NULL */
  96 #define COOKIE_VAL(v) (* ((magic_t *) Data_custom_val(v)))
  97
  98 /* If the cookie has not been forcibly closed with [magic_close], free it. */
  99 static void free_cookie(value c)
 100 {
 101   magic_t cookie = COOKIE_VAL(c);
 102   if (cookie != NULL) {
 103     magic_close(cookie);
 104     COOKIE_VAL(c) = NULL;
 105   }
 106 }
 107
 108 /* compare magic_t pointers (=> total order) */
 109 static int compare_cookie(value c1, value c2)
 110 {
 111   magic_t cookie1 = COOKIE_VAL(c1), cookie2 = COOKIE_VAL(c2);
 112
 113   if (cookie1 == cookie2)      return 0;
 114   else if (cookie1 < cookie2)  return -1;
 115   else return 1;
 116 }
 117
 118 static struct custom_operations cookie_ops = {
 119     /* identifier */ "be.ac.umh.math/magic.cookie." CAML_MAGIC_VERSION,
 120     /* finalize */ free_cookie,
 121     /* compare */ compare_cookie,
 122     /* hash */ custom_hash_default,
 123     /* serialize */ custom_serialize_default,
 124     /* deserialize */ custom_deserialize_default
 125 };
 126
 127 #define ALLOC_COOKIE alloc_custom(&cookie_ops, sizeof(magic_t), \
 128                      sizeof(magic_t), 40 * sizeof(magic_t))
 129
 130 /*
 131  * Stubs
 132  */
 133
 134 CAMLprim value ocaml_magic_open(value flags)
 135 {
 136   CAMLparam1(flags);
 137   CAMLlocal1(c);
 138   char *errmsg;
 139   int len = 80;
 140
 141   c = ALLOC_COOKIE;
 142   if ((COOKIE_VAL(c) = magic_open(Int_val(flags) | MAGIC_ERROR)) == NULL) {
 143     if (errno == EINVAL)
 144       /* An unsupported value for flags was given */
 145       raise_magic_failure("Magiclib.create: Preserve_atime not supported");
 146     else {
 147       /* No cookie yet, so one cannot use the above generic err fun */
 148       if ((errmsg = malloc(len)) == NULL) raise_out_of_memory();
 149       strcpy(errmsg, "Magiclib.create: "); /* 14 chars */
 150 #ifdef HAVE_STRERROR_R
 151       while (strerror_r(errno, errmsg + 14, len - 14) < 0) {
 152         len *= 2;
 153         if ((errmsg = realloc(errmsg, len)) == NULL) raise_out_of_memory();
 154       }
 155 #else
 156       strcat (errmsg, strerror(errno));
 157 #endif
 158       raise_sys_error(copy_string(errmsg));
 159     }
 160   }
 161   CAMLreturn(c);
 162 }
 163
 164 CAMLprim value ocaml_magic_close(value c)
 165 {
 166   CAMLparam1(c);
 167   magic_t cookie = COOKIE_VAL(c);
 168   if (cookie != NULL) /* if first time it is called */
 169     magic_close(cookie);
 170   COOKIE_VAL(c) = NULL; /* For the finalization function & multiple calls */
 171   CAMLreturn(Val_unit);
 172 }
 173
 174
 175 CAMLprim value ocaml_magic_file(value c, value fname)
 176 {
 177   CAMLparam2(c, fname);
 178   const char * ans;
 179   magic_t cookie = COOKIE_VAL(c);
 180
 181   if (cookie == NULL) invalid_argument("Magiclib.file");
 182   if ((ans = magic_file(cookie, String_val(fname))) == NULL) {
 183     raise_on_error("Magiclib.file: ", cookie);
 184   }
 185   CAMLreturn(copy_string(ans));
 186 }
 187
 188 CAMLprim value ocaml_magic_buffer(value c, value buf, value len)
 189 {
 190   CAMLparam3(c, buf, len);
 191   const char * ans;
 192   magic_t cookie = COOKIE_VAL(c);
 193
 194   if (cookie == NULL) caml_invalid_argument("Magiclib.buffer");
 195   if ((ans = magic_buffer(cookie, String_val(buf), Int_val(len)))
 196       == NULL)
 197     raise_on_error("Magiclib.buffer: ", cookie);
 198   CAMLreturn(copy_string(ans));
 199 }
 200
 201
 202 CAMLprim value ocaml_magic_setflags(value c, value flags)
 203 {
 204   CAMLparam2(c, flags);
 205   magic_t cookie = COOKIE_VAL(c);
 206
 207   if (cookie == NULL) caml_invalid_argument("Magiclib.setflags");
 208   if (magic_setflags(cookie, Int_val(flags)) < 0)
 209     raise_magic_failure("Magiclib.setflags: Preserve_atime not supported");
 210   CAMLreturn(Val_unit);
 211 }
 212
 213
 214
 215 #define CHECK(fname) \
 216   magic_t cookie = COOKIE_VAL(c); \
 217   \
 218   if (cookie == NULL) caml_invalid_argument("Magiclib.check"); \
 219   if (magic_check(cookie, fname) < 0) \
 220     CAMLreturn(Val_false); \
 221   else \
 222     CAMLreturn(Val_true)
 223
 224 CAMLprim value ocaml_magic_check_default(value c)
 225 {
 226   CAMLparam1(c);
 227   CHECK(NULL);
 228 }
 229 CAMLprim value ocaml_magic_check(value c, value filenames)
 230 {
 231   CAMLparam2(c, filenames);
 232   CHECK(String_val(filenames));
 233 }
 234
 235
 236
 237 #define COMPILE(fname) \
 238   magic_t cookie = COOKIE_VAL(c); \
 239   \
 240   if (cookie == NULL) caml_invalid_argument("Magiclib.compile"); \
 241   if (magic_compile(cookie, fname) < 0) \
 242     raise_on_error("Magiclib.compile: ", cookie);  \
 243   CAMLreturn(Val_unit)
 244
 245 CAMLprim value ocaml_magic_compile_default(value c)
 246 {
 247   CAMLparam1(c);
 248   COMPILE(NULL);
 249 }
 250
 251 CAMLprim value ocaml_magic_compile(value c, value filenames)
 252 {
 253   CAMLparam2(c, filenames);
 254   COMPILE(String_val(filenames));
 255 }
 256
 257
 258
 259 #define LOAD(fname) \
 260   magic_t cookie = COOKIE_VAL(c); \
 261   \
 262   if (cookie == NULL) caml_invalid_argument("Magiclib.load"); \
 263   if (magic_load(cookie, fname) < 0) \
 264     raise_on_error("Magiclib.load: ", cookie);  \
 265   CAMLreturn(Val_unit)
 266
 267 CAMLprim
 268 value ocaml_magic_load_default(value c)
 269 {
 270   CAMLparam1(c);
 271   LOAD(NULL);
 272 }
 273
 274 CAMLprim
 275 value ocaml_magic_load(value c, value filenames)
 276 {
 277   CAMLparam2(c, filenames);
 278   LOAD(String_val(filenames));
 279 }
 280