Imported Upstream version 3.3.1
[debian/amanda] / perl / Amanda / Device.c
index 0b4111811399539f86d26775531a670349a9d156..cfbb55fda36a96565203b0d946da124ab46f5298 100644 (file)
@@ -1,6 +1,6 @@
 /* ----------------------------------------------------------------------------
  * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 1.3.33
+ * Version 2.0.4
  * 
  * This file is not intended to be easily readable and contains a number of 
  * coding conventions designed to improve portability and efficiency. Do not make
@@ -8,8 +8,12 @@
  * interface file instead. 
  * ----------------------------------------------------------------------------- */
 
+#include "../config/config.h"
+
+
 #define SWIGPERL
 #define SWIG_CASTRANK_MODE
+
 /* -----------------------------------------------------------------------------
  *  This section contains generic SWIG labels for method/variable
  *  declarations/attributes, and other compiler dependent labels.
 # endif
 #endif
 
+#ifndef SWIG_MSC_UNSUPPRESS_4505
+# if defined(_MSC_VER)
+#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
+# endif 
+#endif
+
 #ifndef SWIGUNUSEDPARM
 # ifdef __cplusplus
 #   define SWIGUNUSEDPARM(p)
 /* -----------------------------------------------------------------------------
  * swigrun.swg
  *
- * This file contains generic CAPI SWIG runtime support for pointer
+ * This file contains generic C API SWIG runtime support for pointer
  * type checking.
  * ----------------------------------------------------------------------------- */
 
 /* This should only be incremented when either the layout of swig_type_info changes,
    or for whatever reason, the runtime changes incompatibly */
-#define SWIG_RUNTIME_VERSION "3"
+#define SWIG_RUNTIME_VERSION "4"
 
 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 #ifdef SWIG_TYPE_TABLE
 
 /*
   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
-  creating a static or dynamic library from the swig runtime code.
-  In 99.9% of the cases, swig just needs to declare them as 'static'.
+  creating a static or dynamic library from the SWIG runtime code.
+  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
   
-  But only do this if is strictly necessary, ie, if you have problems
-  with your compiler or so.
+  But only do this if strictly necessary, ie, if you have problems
+  with your compiler or suchlike.
 */
 
 #ifndef SWIGRUNTIME
 
 /* Flags for pointer conversions */
 #define SWIG_POINTER_DISOWN        0x1
+#define SWIG_CAST_NEW_MEMORY       0x2
 
 /* Flags for new pointer objects */
 #define SWIG_POINTER_OWN           0x1
 /* 
    Flags/methods for returning states.
    
-   The swig conversion methods, as ConvertPtr, return and integer 
+   The SWIG conversion methods, as ConvertPtr, return an integer 
    that tells if the conversion was successful or not. And if not,
    an error code can be returned (see swigerrors.swg for the codes).
    
    Use the following macros/flags to set or process the returning
    states.
    
-   In old swig versions, you usually write code as:
+   In old versions of SWIG, code such as the following was usually written:
 
      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
        // success code
        //fail code
      }
 
-   Now you can be more explicit as:
+   Now you can be more explicit:
 
     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
     if (SWIG_IsOK(res)) {
       // fail code
     }
 
-   that seems to be the same, but now you can also do
+   which is the same really, but now you can also do
 
     Type *ptr;
     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
     
    I.e., now SWIG_ConvertPtr can return new objects and you can
    identify the case and take care of the deallocation. Of course that
-   requires also to SWIG_ConvertPtr to return new result values, as
+   also requires SWIG_ConvertPtr to return new result values, such as
 
       int SWIG_ConvertPtr(obj, ptr,...) {         
         if (<obj is ok>) {                            
 
    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
-   swig errors code.
+   SWIG errors code.
 
    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
    allows to return the 'cast rank', for example, if you have this
       fooi(1)   // cast rank '0'
 
    just use the SWIG_AddCast()/SWIG_CheckState()
+*/
 
-
- */
 #define SWIG_OK                    (0) 
 #define SWIG_ERROR                 (-1)
 #define SWIG_IsOK(r)               (r >= 0)
 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 
-
 /* Cast-Rank Mode */
 #if defined(SWIG_CASTRANK_MODE)
 #  ifndef SWIG_TypeRank
@@ -289,18 +298,16 @@ SWIGINTERNINLINE int SWIG_CheckState(int r) {
 #endif
 
 
-
-
 #include <string.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef void *(*swig_converter_func)(void *);
+typedef void *(*swig_converter_func)(void *, int *);
 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 
-/* Structure to store inforomation on one type */
+/* Structure to store information on one type */
 typedef struct swig_type_info {
   const char             *name;                        /* mangled name of this type */
   const char             *str;                 /* human readable name of this type */
@@ -387,48 +394,66 @@ SWIG_TypeCompare(const char *nb, const char *tb) {
 }
 
 
-/* think of this as a c++ template<> or a scheme macro */
-#define SWIG_TypeCheck_Template(comparison, ty)         \
-  if (ty) {                                             \
-    swig_cast_info *iter = ty->cast;                    \
-    while (iter) {                                      \
-      if (comparison) {                                 \
-        if (iter == ty->cast) return iter;              \
-        /* Move iter to the top of the linked list */   \
-        iter->prev->next = iter->next;                  \
-        if (iter->next)                                 \
-          iter->next->prev = iter->prev;                \
-        iter->next = ty->cast;                          \
-        iter->prev = 0;                                 \
-        if (ty->cast) ty->cast->prev = iter;            \
-        ty->cast = iter;                                \
-        return iter;                                    \
-      }                                                 \
-      iter = iter->next;                                \
-    }                                                   \
-  }                                                     \
-  return 0
-
 /*
   Check the typename
 */
 SWIGRUNTIME swig_cast_info *
 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
-  SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (strcmp(iter->type->name, c) == 0) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
-/* Same as previous function, except strcmp is replaced with a pointer comparison */
+/* 
+  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
+*/
 SWIGRUNTIME swig_cast_info *
-SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
-  SWIG_TypeCheck_Template(iter->type == from, into);
+SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if (iter->type == from) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
 /*
   Cast a pointer up an inheritance hierarchy
 */
 SWIGRUNTIMEINLINE void *
-SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
-  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
+SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
+  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
 }
 
 /* 
@@ -872,6 +897,7 @@ SWIG_Perl_ErrorType(int code) {
 
 /* for raw pointers */
 #define SWIG_ConvertPtr(obj, pp, type, flags)           SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
+#define SWIG_ConvertPtrAndOwn(obj, pp, type, flags,own) SWIG_Perl_ConvertPtrAndOwn(SWIG_PERL_OBJECT_CALL obj, pp, type, flags, own)
 #define SWIG_NewPointerObj(p, type, flags)              SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
 
 /* for raw packed data */
@@ -1059,20 +1085,43 @@ SWIG_Perl_TypeProxyName(const swig_type_info *type) {
   }
 }
 
+/* Identical to SWIG_TypeCheck, except for strcmp comparison */
 SWIGRUNTIME swig_cast_info *
 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
-  SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp((char*)iter->type->name, c) == 0)) 
-                           || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
+  if (ty) {
+    swig_cast_info *iter = ty->cast;
+    while (iter) {
+      if ( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0)) ||
+            (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0)) ) {
+        if (iter == ty->cast)
+          return iter;
+        /* Move iter to the top of the linked list */
+        iter->prev->next = iter->next;
+        if (iter->next)
+          iter->next->prev = iter->prev;
+        iter->next = ty->cast;
+        iter->prev = 0;
+        if (ty->cast) ty->cast->prev = iter;
+        ty->cast = iter;
+        return iter;
+      }
+      iter = iter->next;
+    }
+  }
+  return 0;
 }
 
-
 /* Function for getting a pointer value */
 
 SWIGRUNTIME int
-SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+SWIG_Perl_ConvertPtrAndOwn(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags, int *own) {
   swig_cast_info *tc;
   void *voidptr = (void *)0;
   SV *tsv = 0;
+
+  if (own)
+    *own = 0;
+
   /* If magical, apply more magic */
   if (SvGMAGICAL(sv))
     mg_get(sv);
@@ -1104,8 +1153,14 @@ SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *
     return SWIG_OK;
   } else if (SvTYPE(sv) == SVt_RV) {  /* Check for NULL pointer */
     if (!SvROK(sv)) {
-      *(ptr) = (void *) 0;
-      return SWIG_OK;
+      /* In Perl 5.12 and later, SVt_RV == SVt_IV, so sv could be a valid integer value.  */
+      if (SvIOK(sv)) {
+        return SWIG_ERROR;
+      } else {
+        /* NULL pointer (reference to undef). */
+        *(ptr) = (void *) 0;
+        return SWIG_OK;
+      }
     } else {
       return SWIG_ERROR;
     }
@@ -1119,7 +1174,15 @@ SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *
     if (!tc) {
       return SWIG_ERROR;
     }
-    *ptr = SWIG_TypeCast(tc,voidptr);
+    {
+      int newmemory = 0;
+      *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
+      if (newmemory == SWIG_CAST_NEW_MEMORY) {
+        assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
+        if (own)
+          *own = *own | SWIG_CAST_NEW_MEMORY;
+      }
+    }
   } else {
     *ptr = voidptr;
   }
@@ -1133,7 +1196,7 @@ SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *
      */
     SV *obj = sv;
     HV *stash = SvSTASH(SvRV(obj));
-    GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
+    GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
     if (isGV(gv)) {
       HV *hv = GvHVn(gv);
       /*
@@ -1148,9 +1211,14 @@ SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *
   return SWIG_OK;
 }
 
+SWIGRUNTIME int
+SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
+  return SWIG_Perl_ConvertPtrAndOwn(sv, ptr, _t, flags, 0);
+}
+
 SWIGRUNTIME void
 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
-  if (ptr && (flags & SWIG_SHADOW)) {
+  if (ptr && (flags & (SWIG_SHADOW | SWIG_POINTER_OWN))) {
     SV *self;
     SV *obj=newSV(0);
     HV *hash=newHV();
@@ -1159,7 +1227,7 @@ SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, i
     stash=SvSTASH(SvRV(obj));
     if (flags & SWIG_POINTER_OWN) {
       HV *hv;
-      GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
+      GV *gv = *(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
       if (!isGV(gv))
         gv_init(gv, stash, "OWNER", 5, FALSE);
       hv=GvHVn(gv);
@@ -1294,7 +1362,7 @@ SWIG_Perl_GetModule(void) {
 
   /* first check if pointer already created */
   if (!type_pointer) {
-    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE);
+    pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
     if (pointer && SvOK(pointer)) {
       type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
     }
@@ -1308,7 +1376,7 @@ SWIG_Perl_SetModule(swig_module_info *module) {
   SV *pointer;
 
   /* create a new pointer */
-  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE);
+  pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
   sv_setiv(pointer, PTR2IV(module));
 }
 
@@ -1325,6 +1393,9 @@ SWIG_Perl_SetModule(swig_module_info *module) {
 #ifdef do_close
   #undef do_close
 #endif
+#ifdef do_exec
+  #undef do_exec
+#endif
 #ifdef scalar
   #undef scalar
 #endif
@@ -1409,6 +1480,18 @@ SWIG_Perl_SetModule(swig_module_info *module) {
 #ifdef open
   #undef open
 #endif
+#ifdef readdir
+  #undef readdir
+#endif
+#ifdef bind
+  #undef bind
+#endif
+#ifdef access
+  #undef access
+#endif
+#ifdef stat
+  #undef stat
+#endif
 
 
 
@@ -1425,18 +1508,23 @@ SWIG_Perl_SetModule(swig_module_info *module) {
 
 #define SWIGTYPE_p_Device swig_types[0]
 #define SWIGTYPE_p_DevicePropertyBase swig_types[1]
-#define SWIGTYPE_p_GValue swig_types[2]
-#define SWIGTYPE_p_a_STRMAX__char swig_types[3]
-#define SWIGTYPE_p_char swig_types[4]
-#define SWIGTYPE_p_double swig_types[5]
-#define SWIGTYPE_p_dumpfile_t swig_types[6]
-#define SWIGTYPE_p_float swig_types[7]
-#define SWIGTYPE_p_guint swig_types[8]
-#define SWIGTYPE_p_guint64 swig_types[9]
-#define SWIGTYPE_p_int swig_types[10]
-#define SWIGTYPE_p_unsigned_char swig_types[11]
-static swig_type_info *swig_types[13];
-static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0};
+#define SWIGTYPE_p_DirectTCPAddr swig_types[2]
+#define SWIGTYPE_p_DirectTCPConnection swig_types[3]
+#define SWIGTYPE_p_GSList swig_types[4]
+#define SWIGTYPE_p_GValue swig_types[5]
+#define SWIGTYPE_p_a_STRMAX__char swig_types[6]
+#define SWIGTYPE_p_char swig_types[7]
+#define SWIGTYPE_p_double swig_types[8]
+#define SWIGTYPE_p_dumpfile_t swig_types[9]
+#define SWIGTYPE_p_float swig_types[10]
+#define SWIGTYPE_p_guint swig_types[11]
+#define SWIGTYPE_p_guint32 swig_types[12]
+#define SWIGTYPE_p_guint64 swig_types[13]
+#define SWIGTYPE_p_int swig_types[14]
+#define SWIGTYPE_p_p_DirectTCPAddr swig_types[15]
+#define SWIGTYPE_p_unsigned_char swig_types[16]
+static swig_type_info *swig_types[18];
+static swig_module_info swig_module = {swig_types, 17, 0, 0, 0, 0};
 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
 
@@ -1447,7 +1535,7 @@ static swig_module_info swig_module = {swig_types, 12, 0, 0, 0, 0};
 #define SWIG_name   "Amanda::Devicec::boot_Amanda__Device"
 #define SWIG_prefix "Amanda::Devicec::"
 
-#define SWIGVERSION 0x010333 
+#define SWIGVERSION 0x020004 
 #define SWIG_VERSION SWIGVERSION
 
 
@@ -1481,11 +1569,20 @@ SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
 #include "device.h"
 #include "property.h"
 #include "fileheader.h"
+#include "glib-util.h"
+#include "simpleprng.h"
+#include "amanda.h"
+#include "sockaddr-util.h"
 
 
 
 /* Utility functions for typemaps, below */
 
+/* return a new, mortal SV corresponding to the given GValue
+ *
+ * @param value: the value to convert
+ * @returns: a new, mortal SV
+ */
 static SV *
 set_sv_from_gvalue(GValue *value)
 {
@@ -1495,44 +1592,16 @@ set_sv_from_gvalue(GValue *value)
     /* complex reference types */
     switch (fundamental) {
        case G_TYPE_LONG:
-           sv = sv_2mortal(amglue_newSVi64(g_value_get_long(value)));
-           break;
+           return sv_2mortal(amglue_newSVi64(g_value_get_long(value)));
 
        case G_TYPE_ULONG:
-           sv = sv_2mortal(amglue_newSVu64(g_value_get_ulong(value)));
-           break;
+           return sv_2mortal(amglue_newSVu64(g_value_get_ulong(value)));
 
        case G_TYPE_INT64:
-           sv = sv_2mortal(amglue_newSVi64(g_value_get_int64(value)));
-           break;
+           return sv_2mortal(amglue_newSVi64(g_value_get_int64(value)));
 
        case G_TYPE_UINT64:
-           sv = sv_2mortal(amglue_newSVu64(g_value_get_uint64(value)));
-           break;
-
-       case G_TYPE_BOXED: {
-           GType boxed_type = G_VALUE_TYPE(value);
-           QualifiedSize qs;
-           HV *hv;
-
-           if (boxed_type == QUALIFIED_SIZE_TYPE) {
-               qs = *(QualifiedSize*)(g_value_get_boxed(value));
-               
-               /* build a hash */
-               hv = (HV *)sv_2mortal((SV *)newHV());
-               hv_store(hv, "accuracy", 8, newSViv(qs.accuracy), 0);
-               hv_store(hv, "bytes", 5, amglue_newSVi64(qs.bytes), 0);
-
-               sv = newRV((SV *)hv);
-               return newRV((SV *)hv);
-           } else {
-               warn("Unsupported boxed property type #%d", boxed_type);
-
-               sv = sv_newmortal();
-               sv_setsv(sv, &PL_sv_undef);
-               return sv;
-           }
-       }
+           return sv_2mortal(amglue_newSVu64(g_value_get_uint64(value)));
     }
 
     /* simple types that can be constructed with sv_set*v */
@@ -1584,7 +1653,7 @@ set_sv_from_gvalue(GValue *value)
        case G_TYPE_INTERFACE:
        case G_TYPE_OBJECT:
        case G_TYPE_PARAM:
-           warn("Unsupported fundamental property type #%d", fundamental);
+           warn("Unsupported fundamental property type #%d", (int)fundamental);
            sv_setsv(sv, &PL_sv_undef);
            break;
     }
@@ -1592,89 +1661,97 @@ set_sv_from_gvalue(GValue *value)
     return sv;
 }
 
+/* Given an SV and an initialized GValue, set the GValue to the value
+ * represented by the SV.  The GValue's type must already be set.
+ *
+ * For basic corresponding types (string -> string, integer -> integer),
+ * the translation is straightforward.  However, if the GValue is not a
+ * string, but the SV has a string value, then g_value_set_from_string will
+ * be used to parse the string.
+ *
+ * @param sv: SV to convert
+ * @param value: (input/output) destination
+ * @returns: TRUE on success
+ */
 static gboolean
 set_gvalue_from_sv(SV *sv, GValue *value)
 {
     GType fundamental = G_TYPE_FUNDAMENTAL(G_VALUE_TYPE(value));
-    switch (fundamental) {
-       case G_TYPE_CHAR:
-           if (!SvIOK(sv)) return FALSE;
-           g_value_set_char(value, SvIV(sv));
-           break;
 
-       case G_TYPE_UCHAR:
-           if (!SvIOK(sv)) return FALSE;
-           g_value_set_uchar(value, SvUV(sv));
-           break;
+    /* if we got a string, use g_value_set_from_string to parse any funny
+     * values or suffixes */
+    if (SvPOK(sv)) {
+       if (g_value_set_from_string(value, SvPV_nolen(sv)))
+           return TRUE;
+    }
 
+    /* otherwise, handle numeric types with SvIV, SvNV, or the amglue_* functions */
+    switch (fundamental) {
        case G_TYPE_BOOLEAN:
-           if (!SvIOK(sv)) return FALSE;
            g_value_set_boolean(value, SvIV(sv));
-           break;
+           return TRUE;
+
+       case G_TYPE_CHAR:
+           g_value_set_char(value, amglue_SvI8(sv));
+           return TRUE;
+
+       case G_TYPE_UCHAR:
+           g_value_set_uchar(value, amglue_SvU8(sv));
+           return TRUE;
 
        case G_TYPE_INT:
            g_value_set_int(value, amglue_SvI32(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_UINT:
            g_value_set_uint(value, amglue_SvU32(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_LONG:
            g_value_set_int64(value, amglue_SvI64(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_ULONG:
            g_value_set_uint64(value, amglue_SvU64(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_INT64:
            g_value_set_int64(value, amglue_SvI64(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_UINT64:
            g_value_set_uint64(value, amglue_SvU64(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_FLOAT:
-           if (!SvNOK(sv)) return FALSE;
            g_value_set_float(value, SvNV(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_DOUBLE:
-           if (!SvNOK(sv)) return FALSE;
            g_value_set_double(value, SvNV(sv));
-           break;
-
-       case G_TYPE_STRING:
-           if (!SvPOK(sv)) return FALSE;
-           g_value_set_string(value, SvPV_nolen(sv));
-           break;
+           return TRUE;
 
-       case G_TYPE_ENUM: 
-           if (!SvIOK(sv)) return FALSE;
+       case G_TYPE_ENUM:
            g_value_set_enum(value, SvIV(sv));
-           break;
+           return TRUE;
 
        case G_TYPE_FLAGS:
-           if (!SvIOK(sv)) return FALSE;
            g_value_set_flags(value, SvIV(sv));
-           break;
+           return TRUE;
 
-       /* Unsupported */
        default:
-       case G_TYPE_POINTER:
-       case G_TYPE_INTERFACE:
-       case G_TYPE_BOXED: /* note: *getting* boxed values is supported */
-       case G_TYPE_OBJECT:
-       case G_TYPE_PARAM:
-           return FALSE;
+           /* for anything else, let perl stringify it for us and try parsing it */
+           return g_value_set_from_string(value, SvPV_nolen(sv));
     }
-
-    return TRUE;
 }
 
 
+SWIGINTERN void delete_DirectTCPConnection(DirectTCPConnection *self){
+           g_object_unref(self);
+       }
+SWIGINTERN char *DirectTCPConnection_close(DirectTCPConnection *self){
+           return directtcp_connection_close(self);
+       }
 
 SWIGINTERNINLINE SV *
 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
@@ -1712,6 +1789,11 @@ SWIG_pchar_descriptor(void)
 SWIGINTERN int
 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
 {
+  if (SvMAGICAL(obj)) {
+     SV *tmp = sv_newmortal();
+     SvSetSV(tmp, obj);
+     obj = tmp;
+  }
   if (SvPOK(obj)) {
     STRLEN len = 0;
     char *cstr = SvPV(obj, len); 
@@ -1752,9 +1834,6 @@ SWIGINTERN Device *new_Device(char *device_name){
 SWIGINTERN void delete_Device(Device *self){
            g_object_unref(self);
        }
-SWIGINTERN ReadLabelStatusFlags Device_read_label(Device *self){
-           return device_read_label(self);
-       }
 
 #include <limits.h>
 #if !defined(SWIG_NO_LLONG_MAX)
@@ -1779,7 +1858,9 @@ SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
     const char *nptr = SvPV_nolen(obj);
     if (nptr) {
       char *endptr;
-      double v = strtod(nptr, &endptr);
+      double v;
+      errno = 0;
+      v = strtod(nptr, &endptr);
       if (errno == ERANGE) {
        errno = 0;
        return SWIG_OverflowError;
@@ -1883,29 +1964,32 @@ SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
   return res;
 }
 
+SWIGINTERN gboolean Device_configure(Device *self,gboolean use_global_config){
+           return device_configure(self, use_global_config);
+       }
+SWIGINTERN char *Device_error(Device *self){
+           return device_error(self);
+       }
+SWIGINTERN char *Device_status_error(Device *self){
+           return device_status_error(self);
+       }
+SWIGINTERN char *Device_error_or_status(Device *self){
+           return device_error_or_status(self);
+       }
+SWIGINTERN DeviceStatusFlags Device_read_label(Device *self){
+           return device_read_label(self);
+       }
 SWIGINTERN gboolean Device_start(Device *self,DeviceAccessMode mode,char *label,char *timestamp){
            return device_start(self, mode, label, timestamp);
        }
 SWIGINTERN gboolean Device_finish(Device *self){
            return device_finish(self);
        }
-SWIGINTERN gboolean Device_start_file(Device *self,dumpfile_t const *jobInfo){
+SWIGINTERN gboolean Device_start_file(Device *self,dumpfile_t *jobInfo){
            return device_start_file(self, jobInfo);
        }
-SWIGINTERN guint Device_write_min_size(Device *self){
-           return device_write_min_size(self);
-       }
-SWIGINTERN guint Device_write_max_size(Device *self){
-           return device_write_max_size(self);
-       }
-SWIGINTERN guint Device_read_max_size(Device *self){
-           return device_read_max_size(self);
-       }
-SWIGINTERN gboolean Device_write_block(Device *self,guint size,gpointer data,gboolean short_block){
-           return device_write_block(self, size, data, short_block);
-       }
-SWIGINTERN gboolean Device_write_from_fd(Device *self,int fd){
-           return device_write_from_fd(self, fd);
+SWIGINTERN gboolean Device_write_block(Device *self,guint size,gpointer data){
+           return device_write_block(self, size, data);
        }
 SWIGINTERN gboolean Device_finish_file(Device *self){
            return device_finish_file(self);
@@ -1919,23 +2003,91 @@ SWIGINTERN gboolean Device_seek_block(Device *self,guint64 block){
 SWIGINTERN int Device_read_block(Device *self,gpointer buffer,int *size){
            return device_read_block(self, buffer, size);
        }
-SWIGINTERN gboolean Device_read_to_fd(Device *self,int fd){
-           return device_read_to_fd(self, fd);
+SWIGINTERN gboolean Device_erase(Device *self){
+           return device_erase(self);
+       }
+SWIGINTERN gboolean Device_eject(Device *self){
+           return device_eject(self);
+       }
+SWIGINTERN gboolean Device_directtcp_supported(Device *self){
+           return device_directtcp_supported(self);
+       }
+SWIGINTERN void Device_listen(Device *self,gboolean for_writing,DirectTCPAddr **addrs){
+           /* ensure that the addresses are empty if there was an error */
+           if (!device_listen(self, for_writing, addrs))
+               *addrs = NULL;
+       }
+SWIGINTERN DirectTCPConnection *Device_accept(Device *self){
+           DirectTCPConnection *conn = NULL;
+           gboolean rv;
+
+           rv = device_accept(self, &conn, NULL, NULL);
+           if (!rv && conn) {
+               /* conn is ref'd for our convenience, but we don't want it */
+               g_object_unref(conn);
+               conn = NULL;
+           }
+           return conn;
+       }
+SWIGINTERN DirectTCPConnection *Device_connect(Device *self,gboolean for_writing,DirectTCPAddr *addrs){
+           DirectTCPConnection *conn = NULL;
+           gboolean rv;
+
+           rv = device_connect(self, for_writing, addrs, &conn, NULL, NULL);
+           if (!rv && conn) {
+               /* conn is ref'd for our convenience, but we don't want it */
+               g_object_unref(conn);
+               conn = NULL;
+           }
+           return conn;
+       }
+SWIGINTERN gboolean Device_use_connection(Device *self,DirectTCPConnection *conn){
+           return device_use_connection(self, conn);
        }
-SWIGINTERN DeviceProperty const *Device_property_list(Device *self){
+SWIGINTERN gboolean Device_write_from_connection(Device *self,guint64 size,guint64 *actual_size){
+           return device_write_from_connection(self, size, actual_size);
+       }
+SWIGINTERN gboolean Device_read_to_connection(Device *self,guint64 size,guint64 *actual_size){
+           return device_read_to_connection(self, size, actual_size);
+       }
+SWIGINTERN GSList const *Device_property_list(Device *self){
            return device_property_get_list(self);
        }
-SWIGINTERN void Device_property_get(Device *self,DevicePropertyBase *pbase,GValue *out_val,gboolean *val_found){
-           *val_found = device_property_get(self, pbase->ID, out_val);
+SWIGINTERN void Device_property_get(Device *self,DevicePropertyBase *pbase,GValue *out_val,PropertySurety *surety,PropertySource *source,gboolean *val_found){
+           if (pbase) {
+               *val_found = device_property_get_ex(self, pbase->ID, out_val, surety, source);
+           } else {
+               *val_found = FALSE;
+           }
        }
 SWIGINTERN gboolean Device_property_set(Device *self,DevicePropertyBase *pbase,SV *sv){
            GValue gval;
+
+           if (!pbase)
+               goto fail;
            memset(&gval, 0, sizeof(gval));
            g_value_init(&gval, pbase->type);
            if (!set_gvalue_from_sv(sv, &gval))
-               goto fail;
+               goto failunset;
 
            if (!device_property_set(self, pbase->ID, &gval))
+               goto failunset;
+
+           g_value_unset(&gval);
+           return TRUE;
+       failunset:
+           g_value_unset(&gval);
+       fail:
+           return FALSE;
+       }
+SWIGINTERN gboolean Device_property_set_ex(Device *self,DevicePropertyBase *pbase,SV *sv,PropertySurety surety,PropertySource source){
+           GValue gval;
+           memset(&gval, 0, sizeof(gval));
+           g_value_init(&gval, pbase->type);
+           if (!set_gvalue_from_sv(sv, &gval))
+               goto fail;
+
+           if (!device_property_set_ex(self, pbase->ID, &gval, surety, source))
                goto fail;
 
            g_value_unset(&gval);
@@ -1947,9 +2099,151 @@ SWIGINTERN gboolean Device_property_set(Device *self,DevicePropertyBase *pbase,S
 SWIGINTERN gboolean Device_recycle_file(Device *self,guint filenum){
            return device_recycle_file(self, filenum);
        }
-SWIGINTERN void Device_set_startup_properties_from_config(Device *self){
-           device_set_startup_properties_from_config(self);
+SWIGINTERN int Device_file(Device *self){ return self->file; }
+SWIGINTERN guint64 Device_block(Device *self){ return self->block; }
+SWIGINTERN gboolean Device_in_file(Device *self){ return self->in_file; }
+SWIGINTERN char *Device_device_name(Device *self){ return self->device_name; }
+SWIGINTERN DeviceAccessMode Device_access_mode(Device *self){ return self->access_mode; }
+SWIGINTERN gboolean Device_is_eof(Device *self){ return self->is_eof; }
+SWIGINTERN gboolean Device_is_eom(Device *self){ return self->is_eom; }
+SWIGINTERN char *Device_volume_label(Device *self){ return self->volume_label; }
+SWIGINTERN char *Device_volume_time(Device *self){ return self->volume_time; }
+SWIGINTERN DeviceStatusFlags Device_status(Device *self){ return self->status; }
+SWIGINTERN gsize Device_min_block_size(Device *self){ return self->min_block_size; }
+SWIGINTERN gsize Device_max_block_size(Device *self){ return self->max_block_size; }
+SWIGINTERN gsize Device_block_size(Device *self){ return self->block_size; }
+SWIGINTERN gsize Device_header_block_size(Device *self){ return self->header_block_size; }
+SWIGINTERN dumpfile_t *Device_volume_header(Device *self){ return self->volume_header; }
+
+
+/* write LENGTH bytes of random data to FILENAME, seeded with SEED */
+gboolean
+write_random_to_device(guint32 seed, size_t length, Device *device) {
+    simpleprng_state_t prng;
+    char *buf;
+    gsize block_size = device->block_size;
+    g_assert(block_size < G_MAXUINT);
+
+    buf = g_malloc(block_size);
+    simpleprng_seed(&prng, seed);
+
+    while (length) {
+       size_t to_write = min(block_size, length);
+
+       simpleprng_fill_buffer(&prng, buf, to_write);
+       if (!device_write_block(device, (guint)block_size, buf)) {
+           g_free(buf);
+           return FALSE;
+       }
+       length -= to_write;
+    }
+
+    g_free(buf);
+    return TRUE;
+}
+
+/* read LENGTH bytes of random data from FILENAME verifying it against
+ * a PRNG seeded with SEED.  Sends any error messages to stderr.
+ */
+gboolean
+verify_random_from_device(guint32 seed, size_t length, Device *device) {
+    simpleprng_state_t prng;
+    char *buf = NULL; /* first device_read_block will get the size */
+    int block_size = 0;
+
+    simpleprng_seed(&prng, seed);
+
+    while (length) {
+       int bytes_read;
+       int size = block_size;
+
+       bytes_read = device_read_block(device, buf, &size);
+       if (bytes_read == 0 && size > block_size) {
+           g_free(buf);
+           block_size = size;
+           buf = g_malloc(block_size);
+           continue;
+       }
+       if (bytes_read == -1) {
+           if (device->status == DEVICE_STATUS_SUCCESS) {
+               g_assert(device->is_eof);
+               g_debug("verify_random_from_device got unexpected EOF");
+           }
+           goto error;
+       }
+
+       /* strip padding */
+       bytes_read = min(bytes_read, length);
+
+       if (!simpleprng_verify_buffer(&prng, buf, bytes_read))
+           goto error;
+
+       length -= bytes_read;
+    }
+
+    g_free(buf);
+    return TRUE;
+
+error:
+    g_free(buf);
+    return FALSE;
+}
+
+
+SWIGINTERN int
+SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val) 
+{
+  if (SvUOK(obj)) {
+    if (val) *val = SvUV(obj);
+    return SWIG_OK;
+  } else  if (SvIOK(obj)) {
+    long v = SvIV(obj);
+    if (v >= 0) {
+      if (val) *val = v;
+      return SWIG_OK;
+    } else {
+      return SWIG_OverflowError;
+    }
+  } else {
+    int dispatch = 0;
+    const char *nptr = SvPV_nolen(obj);
+    if (nptr) {
+      char *endptr;
+      unsigned long v;
+      errno = 0;
+      v = strtoul(nptr, &endptr,0);
+      if (errno == ERANGE) {
+       errno = 0;
+       return SWIG_OverflowError;
+      } else {
+       if (*endptr == '\0') {
+         if (val) *val = v;
+         return SWIG_Str2NumCast(SWIG_OK);
        }
+      }
+    }
+    if (!dispatch) {
+      double d;
+      int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
+      if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
+       if (val) *val = (unsigned long)(d);
+       return res;
+      }
+    }
+  }
+  return SWIG_TypeError;
+}
+
+
+SWIGINTERNINLINE int
+SWIG_AsVal_size_t SWIG_PERL_DECL_ARGS_2(SV * obj, size_t *val)
+{
+  unsigned long v;
+  int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, val ? &v : 0);
+  if (SWIG_IsOK(res) && val) *val = (size_t)(v);
+  return res;
+}
+
 
 SWIGINTERNINLINE SV *
 SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
@@ -1971,8 +2265,8 @@ extern "C" {
 #endif
 
 #ifdef PERL_OBJECT
-#define MAGIC_CLASS _wrap_Amanda::Device_var::
-class _wrap_Amanda::Device_var : public CPerlObj {
+#define MAGIC_CLASS _wrap_Amanda__Device_var::
+class _wrap_Amanda__Device_var : public CPerlObj {
 public:
 #else
 #define MAGIC_CLASS
@@ -1995,28 +2289,24 @@ SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SW
 #ifdef __cplusplus
 extern "C" {
 #endif
-XS(_wrap_Device_file_get) {
+XS(_wrap_delete_DirectTCPConnection) {
   {
-    Device *arg1 = (Device *) 0 ;
-    int result;
+    DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_file_get(self);");
+      SWIG_croak("Usage: delete_DirectTCPConnection(self);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, SWIG_POINTER_DISOWN |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_file_get" "', argument " "1"" of type '" "Device *""'"); 
-    }
-    arg1 = (Device *)(argp1);
-    result = (int) ((arg1)->file);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
-      argvi++;
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DirectTCPConnection" "', argument " "1"" of type '" "DirectTCPConnection *""'"); 
     }
+    arg1 = (DirectTCPConnection *)(argp1);
+    delete_DirectTCPConnection(arg1);
+    ST(argvi) = sv_newmortal();
     
     XSRETURN(argvi);
   fail:
@@ -2026,29 +2316,27 @@ XS(_wrap_Device_file_get) {
 }
 
 
-XS(_wrap_Device_block_get) {
+XS(_wrap_DirectTCPConnection_close) {
   {
-    Device *arg1 = (Device *) 0 ;
-    guint64 result;
+    DirectTCPConnection *arg1 = (DirectTCPConnection *) 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    char *result = 0 ;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_block_get(self);");
+      SWIG_croak("Usage: DirectTCPConnection_close(self);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_DirectTCPConnection, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block_get" "', argument " "1"" of type '" "Device *""'"); 
-    }
-    arg1 = (Device *)(argp1);
-    result =  ((arg1)->block);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVu64(result));
-      argvi++;
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DirectTCPConnection_close" "', argument " "1"" of type '" "DirectTCPConnection *""'"); 
     }
+    arg1 = (DirectTCPConnection *)(argp1);
+    result = (char *)DirectTCPConnection_close(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
+    free((char*)result);
     XSRETURN(argvi);
   fail:
     
@@ -2057,118 +2345,100 @@ XS(_wrap_Device_block_get) {
 }
 
 
-XS(_wrap_Device_in_file_get) {
+XS(_wrap_new_DirectTCPConnection) {
   {
-    Device *arg1 = (Device *) 0 ;
-    gboolean result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
     int argvi = 0;
+    DirectTCPConnection *result = 0 ;
     dXSARGS;
     
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_in_file_get(self);");
+    if ((items < 0) || (items > 0)) {
+      SWIG_croak("Usage: new_DirectTCPConnection();");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_in_file_get" "', argument " "1"" of type '" "Device *""'"); 
-    }
-    arg1 = (Device *)(argp1);
-    result = (gboolean) ((arg1)->in_file);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
-      argvi++;
-    }
-    
+    result = (DirectTCPConnection *)calloc(1, sizeof(DirectTCPConnection));
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
     XSRETURN(argvi);
   fail:
-    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_device_name_get) {
+XS(_wrap_unaliased_name) {
   {
-    Device *arg1 = (Device *) 0 ;
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
+    int argvi = 0;
     char *result = 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
-    int argvi = 0;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_device_name_get(self);");
+      SWIG_croak("Usage: unaliased_name(char *);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_device_name_get" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "unaliased_name" "', argument " "1"" of type '" "char *""'");
     }
-    arg1 = (Device *)(argp1);
-    result = (char *) ((arg1)->device_name);
+    arg1 = (char *)(buf1);
+    result = (char *)device_unaliased_name(arg1);
     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
-    
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
     XSRETURN(argvi);
   fail:
-    
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_access_mode_get) {
+XS(_wrap_new_Device) {
   {
-    Device *arg1 = (Device *) 0 ;
-    DeviceAccessMode result;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
+    char *arg1 = (char *) 0 ;
+    int res1 ;
+    char *buf1 = 0 ;
+    int alloc1 = 0 ;
     int argvi = 0;
+    Device *result = 0 ;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_access_mode_get(self);");
+      SWIG_croak("Usage: new_Device(device_name);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_access_mode_get" "', argument " "1"" of type '" "Device *""'"); 
-    }
-    arg1 = (Device *)(argp1);
-    result = (DeviceAccessMode) ((arg1)->access_mode);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
-      argvi++;
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "char *""'");
     }
-    
+    arg1 = (char *)(buf1);
+    result = (Device *)new_Device(arg1);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
     XSRETURN(argvi);
   fail:
-    
+    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_is_eof_get) {
+XS(_wrap_delete_Device) {
   {
     Device *arg1 = (Device *) 0 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_is_eof_get(self);");
+      SWIG_croak("Usage: delete_Device(self);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, SWIG_POINTER_DISOWN |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eof_get" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Device" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = (gboolean) ((arg1)->is_eof);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
-      argvi++;
-    }
+    delete_Device(arg1);
+    ST(argvi) = sv_newmortal();
     
     XSRETURN(argvi);
   fail:
@@ -2178,52 +2448,64 @@ XS(_wrap_Device_is_eof_get) {
 }
 
 
-XS(_wrap_Device_volume_label_get) {
+XS(_wrap_Device_configure) {
   {
     Device *arg1 = (Device *) 0 ;
-    char *result = 0 ;
+    gboolean arg2 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_volume_label_get(self);");
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_configure(self,use_global_config);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_label_get" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_configure" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = (char *) ((arg1)->volume_label);
-    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    {
+      arg2 = SvTRUE(ST(1));
+    }
+    result = (gboolean)Device_configure(arg1,arg2);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
     
     XSRETURN(argvi);
   fail:
     
+    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_volume_time_get) {
+XS(_wrap_Device_error) {
   {
     Device *arg1 = (Device *) 0 ;
-    char *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    char *result = 0 ;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_volume_time_get(self);");
+      SWIG_croak("Usage: Device_error(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_time_get" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = (char *) ((arg1)->volume_time);
+    result = (char *)Device_error(arg1);
     ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
     XSRETURN(argvi);
@@ -2234,54 +2516,53 @@ XS(_wrap_Device_volume_time_get) {
 }
 
 
-XS(_wrap_new_Device) {
+XS(_wrap_Device_status_error) {
   {
-    char *arg1 = (char *) 0 ;
-    Device *result = 0 ;
-    int res1 ;
-    char *buf1 = 0 ;
-    int alloc1 = 0 ;
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
     int argvi = 0;
+    char *result = 0 ;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: new_Device(device_name);");
+      SWIG_croak("Usage: Device_status_error(self);");
     }
-    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Device" "', argument " "1"" of type '" "char *""'");
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status_error" "', argument " "1"" of type '" "Device *""'"); 
     }
-    arg1 = (char *)(buf1);
-    result = (Device *)new_Device(arg1);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
-    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    arg1 = (Device *)(argp1);
+    result = (char *)Device_status_error(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
     XSRETURN(argvi);
   fail:
-    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
+    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_delete_Device) {
+XS(_wrap_Device_error_or_status) {
   {
     Device *arg1 = (Device *) 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    char *result = 0 ;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: delete_Device(self);");
+      SWIG_croak("Usage: Device_error_or_status(self);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, SWIG_POINTER_DISOWN |  0 );
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Device" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_error_or_status" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    delete_Device(arg1);
-    
-    
+    result = (char *)Device_error_or_status(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
     XSRETURN(argvi);
   fail:
@@ -2294,10 +2575,10 @@ XS(_wrap_delete_Device) {
 XS(_wrap_Device_read_label) {
   {
     Device *arg1 = (Device *) 0 ;
-    ReadLabelStatusFlags result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    DeviceStatusFlags result;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
@@ -2308,9 +2589,13 @@ XS(_wrap_Device_read_label) {
       SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_label" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = (ReadLabelStatusFlags)Device_read_label(arg1);
+    result = (DeviceStatusFlags)Device_read_label(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVi64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
       argvi++;
     }
     
@@ -2328,7 +2613,6 @@ XS(_wrap_Device_start) {
     DeviceAccessMode arg2 ;
     char *arg3 = (char *) 0 ;
     char *arg4 = (char *) 0 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int res3 ;
@@ -2338,6 +2622,7 @@ XS(_wrap_Device_start) {
     char *buf4 = 0 ;
     int alloc4 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
     if ((items < 4) || (items > 4)) {
@@ -2373,7 +2658,10 @@ XS(_wrap_Device_start) {
     arg4 = (char *)(buf4);
     result = (gboolean)Device_start(arg1,arg2,arg3,arg4);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
@@ -2394,10 +2682,10 @@ XS(_wrap_Device_start) {
 XS(_wrap_Device_finish) {
   {
     Device *arg1 = (Device *) 0 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
@@ -2410,7 +2698,10 @@ XS(_wrap_Device_finish) {
     arg1 = (Device *)(argp1);
     result = (gboolean)Device_finish(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
@@ -2426,12 +2717,12 @@ XS(_wrap_Device_start_file) {
   {
     Device *arg1 = (Device *) 0 ;
     dumpfile_t *arg2 = (dumpfile_t *) 0 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     void *argp2 = 0 ;
     int res2 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
     if ((items < 2) || (items > 2)) {
@@ -2444,12 +2735,15 @@ XS(_wrap_Device_start_file) {
     arg1 = (Device *)(argp1);
     res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_dumpfile_t, 0 |  0 );
     if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_start_file" "', argument " "2"" of type '" "dumpfile_t const *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_start_file" "', argument " "2"" of type '" "dumpfile_t *""'"); 
     }
     arg2 = (dumpfile_t *)(argp2);
-    result = (gboolean)Device_start_file(arg1,(dumpfile_t const *)arg2);
+    result = (gboolean)Device_start_file(arg1,arg2);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
@@ -2463,57 +2757,85 @@ XS(_wrap_Device_start_file) {
 }
 
 
-XS(_wrap_Device_write_min_size) {
+XS(_wrap_Device_write_block) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint result;
+    guint arg2 ;
+    gpointer arg3 = (gpointer) 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
+    int res3 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_write_min_size(self);");
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Device_write_block(self,size,data);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_min_size" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_block" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = Device_write_min_size(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVu64(result));
+      if (sizeof(guint) == 1) {
+        arg2 = amglue_SvU8(ST(1));
+      } else if (sizeof(guint) == 2) {
+        arg2 = amglue_SvU16(ST(1));
+      } else if (sizeof(guint) == 4) {
+        arg2 = amglue_SvU32(ST(1));
+      } else if (sizeof(guint) == 8) {
+        arg2 = amglue_SvU64(ST(1));
+      } else {
+        croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
+      }
+    }
+    res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_write_block" "', argument " "3"" of type '" "gpointer""'"); 
+    }
+    result = (gboolean)Device_write_block(arg1,arg2,arg3);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
+    
     XSRETURN(argvi);
   fail:
     
+    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_write_max_size) {
+XS(_wrap_Device_finish_file) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_write_max_size(self);");
+      SWIG_croak("Usage: Device_finish_file(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_max_size" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish_file" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = Device_write_max_size(arg1);
+    result = (gboolean)Device_finish_file(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVu64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
@@ -2525,28 +2847,39 @@ XS(_wrap_Device_write_max_size) {
 }
 
 
-XS(_wrap_Device_read_max_size) {
+XS(_wrap_Device_seek_file) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint result;
+    guint arg2 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    dumpfile_t *result = 0 ;
     dXSARGS;
     
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_read_max_size(self);");
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_seek_file(self,file);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_max_size" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_file" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = Device_read_max_size(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVu64(result));
-      argvi++;
+      if (sizeof(guint) == 1) {
+        arg2 = amglue_SvU8(ST(1));
+      } else if (sizeof(guint) == 2) {
+        arg2 = amglue_SvU16(ST(1));
+      } else if (sizeof(guint) == 4) {
+        arg2 = amglue_SvU32(ST(1));
+      } else if (sizeof(guint) == 8) {
+        arg2 = amglue_SvU64(ST(1));
+      } else {
+        croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
+      }
     }
+    result = (dumpfile_t *)Device_seek_file(arg1,arg2);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
     
     XSRETURN(argvi);
   fail:
@@ -2556,142 +2889,120 @@ XS(_wrap_Device_read_max_size) {
 }
 
 
-XS(_wrap_Device_write_block) {
+XS(_wrap_Device_seek_block) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint arg2 ;
-    gpointer arg3 = (gpointer) 0 ;
-    gboolean arg4 ;
-    gboolean result;
+    guint64 arg2 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
-    int res3 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
-    if ((items < 4) || (items > 4)) {
-      SWIG_croak("Usage: Device_write_block(self,size,data,short_block);");
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_seek_block(self,block);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_block" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_block" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
     {
-      if (sizeof(guint) == 1) {
-        arg2 = amglue_SvU8(ST(1));
-      } else if (sizeof(guint) == 2) {
-        arg2 = amglue_SvU16(ST(1));
-      } else if (sizeof(guint) == 4) {
-        arg2 = amglue_SvU32(ST(1));
-      } else if (sizeof(guint) == 8) {
-        arg2 = amglue_SvU64(ST(1));
-      } else {
-        croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
-      }
-    }
-    res3 = SWIG_ConvertPtr(ST(2),SWIG_as_voidptrptr(&arg3), 0, 0);
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_write_block" "', argument " "3"" of type '" "gpointer""'"); 
-    }
-    {
-      if (sizeof(signed int) == 1) {
-        arg4 = amglue_SvI8(ST(3));
-      } else if (sizeof(signed int) == 2) {
-        arg4 = amglue_SvI16(ST(3));
-      } else if (sizeof(signed int) == 4) {
-        arg4 = amglue_SvI32(ST(3));
-      } else if (sizeof(signed int) == 8) {
-        arg4 = amglue_SvI64(ST(3));
-      } else {
-        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
-      }
+      arg2 = amglue_SvU64(ST(1));
     }
-    result = (gboolean)Device_write_block(arg1,arg2,arg3,arg4);
+    result = (gboolean)Device_seek_block(arg1,arg2);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
-    
-    
     XSRETURN(argvi);
   fail:
     
-    
-    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_write_from_fd) {
+XS(_wrap_Device_read_block) {
   {
     Device *arg1 = (Device *) 0 ;
-    int arg2 ;
-    gboolean result;
+    gpointer arg2 = (gpointer) 0 ;
+    int *arg3 = (int *) 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
+    int res2 ;
+    void *argp3 = 0 ;
+    int res3 = 0 ;
     int argvi = 0;
+    int result;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: Device_write_from_fd(self,fd);");
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Device_read_block(self,buffer,size);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_from_fd" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_block" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    {
-      if (sizeof(signed int) == 1) {
-        arg2 = amglue_SvI8(ST(1));
-      } else if (sizeof(signed int) == 2) {
-        arg2 = amglue_SvI16(ST(1));
-      } else if (sizeof(signed int) == 4) {
-        arg2 = amglue_SvI32(ST(1));
-      } else if (sizeof(signed int) == 8) {
-        arg2 = amglue_SvI64(ST(1));
-      } else {
-        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
-      }
+    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_read_block" "', argument " "2"" of type '" "gpointer""'"); 
+    }
+    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_read_block" "', argument " "3"" of type '" "int *""'"); 
     }
-    result = (gboolean)Device_write_from_fd(arg1,arg2);
+    arg3 = (int *)(argp3);
+    result = (int)Device_read_block(arg1,arg2,arg3);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVi64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
       argvi++;
     }
     
     
+    
     XSRETURN(argvi);
   fail:
     
     
+    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_finish_file) {
+XS(_wrap_Device_erase) {
   {
     Device *arg1 = (Device *) 0 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_finish_file(self);");
+      SWIG_croak("Usage: Device_erase(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_finish_file" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_erase" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = (gboolean)Device_finish_file(arg1);
+    result = (gboolean)Device_erase(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
@@ -2703,39 +3014,957 @@ XS(_wrap_Device_finish_file) {
 }
 
 
-XS(_wrap_Device_seek_file) {
+XS(_wrap_Device_eject) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint arg2 ;
-    dumpfile_t *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: Device_seek_file(self,file);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_eject(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_file" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_eject" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
+    result = (gboolean)Device_eject(arg1);
     {
-      if (sizeof(guint) == 1) {
-        arg2 = amglue_SvU8(ST(1));
-      } else if (sizeof(guint) == 2) {
-        arg2 = amglue_SvU16(ST(1));
-      } else if (sizeof(guint) == 4) {
-        arg2 = amglue_SvU32(ST(1));
-      } else if (sizeof(guint) == 8) {
-        arg2 = amglue_SvU64(ST(1));
-      } else {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_directtcp_supported) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_directtcp_supported(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_directtcp_supported" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (gboolean)Device_directtcp_supported(arg1);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_listen) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    gboolean arg2 ;
+    DirectTCPAddr **arg3 = (DirectTCPAddr **) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    DirectTCPAddr *addrs3 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    {
+      addrs3 = NULL;
+      arg3 = &addrs3;
+    }
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_listen(self,for_writing);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_listen" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      arg2 = SvTRUE(ST(1));
+    }
+    Device_listen(arg1,arg2,arg3);
+    ST(argvi) = sv_newmortal();
+    {
+      if (arg3 && *arg3) {
+        DirectTCPAddr *iter = *arg3;
+        AV *av = newAV();
+        int i = 0;
+        
+        while (iter && SU_GET_FAMILY(iter) != 0) {
+          char *addr = str_sockaddr_no_port(iter);
+          AV *tuple = newAV();
+          
+          g_assert(NULL != av_store(tuple, 0, newSVpv(addr, 0)));
+          g_assert(NULL != av_store(tuple, 1, newSViv(SU_GET_PORT(iter))));
+          g_assert(NULL != av_store(av, i++, newRV_noinc((SV *)tuple)));
+          iter++;
+        }
+        
+        ST(argvi) = newRV_noinc((SV *)av);
+        argvi++;
+      }
+    }
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_accept) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    DirectTCPConnection *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_accept(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_accept" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (DirectTCPConnection *)Device_accept(arg1);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_connect) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    gboolean arg2 ;
+    DirectTCPAddr *arg3 = (DirectTCPAddr *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    DirectTCPConnection *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Device_connect(self,for_writing,addrs);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_connect" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      arg2 = SvTRUE(ST(1));
+    }
+    {
+      AV *addrs_av;
+      int num_addrs, i;
+      
+      if (!SvROK(ST(2)) || SvTYPE(SvRV(ST(2))) != SVt_PVAV) {
+        SWIG_exception_fail(SWIG_TypeError, "must provide an arrayref of DirectTCPAddrs");
+      }
+      addrs_av = (AV *)SvRV(ST(2));
+      num_addrs = av_len(addrs_av)+1;
+      
+      arg3 = g_new0(DirectTCPAddr, num_addrs+1);
+      
+      for (i = 0; i < num_addrs; i++) {
+        SV **svp = av_fetch(addrs_av, i, 0);
+        AV *addr_av;
+        sockaddr_union addr;
+        IV port;
+        
+        if (!svp || !SvROK(*svp) || SvTYPE(SvRV(*svp)) != SVt_PVAV
+          || av_len((AV *)SvRV(*svp))+1 != 2) {
+          SWIG_exception_fail(SWIG_TypeError, "each DirectTCPAddr must be a 2-element arrayref");
+        }
+        
+        addr_av = (AV *)SvRV(*svp);
+        
+        /* get address */
+        svp = av_fetch(addr_av, 0, 0);
+        if (!svp || !SvPOK(*svp) || !str_to_sockaddr(SvPV_nolen(*svp), &addr)) {
+          SWIG_exception_fail(SWIG_TypeError, "invalid IPv4 addr in address");
+        }
+        
+        /* get port */
+        svp = av_fetch(addr_av, 1, 0);
+        if (!svp || !SvIOK(*svp) || (port = SvIV(*svp)) <= 0 || port >= 65536) {
+          SWIG_exception_fail(SWIG_TypeError, "invalid port in address");
+        }
+        SU_SET_PORT(&addr, port);
+        
+        copy_sockaddr(arg3, &addr);
+      }
+    }
+    result = (DirectTCPConnection *)Device_connect(arg1,arg2,arg3);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DirectTCPConnection, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_use_connection) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    DirectTCPConnection *arg2 = (DirectTCPConnection *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    void *argp2 = 0 ;
+    int res2 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_use_connection(self,conn);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_use_connection" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    res2 = SWIG_ConvertPtr(ST(1), &argp2,SWIGTYPE_p_DirectTCPConnection, 0 |  0 );
+    if (!SWIG_IsOK(res2)) {
+      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_use_connection" "', argument " "2"" of type '" "DirectTCPConnection *""'"); 
+    }
+    arg2 = (DirectTCPConnection *)(argp2);
+    result = (gboolean)Device_use_connection(arg1,arg2);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_write_from_connection) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    guint64 arg2 ;
+    guint64 *arg3 = (guint64 *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    guint64 sz3 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    {
+      sz3 = 0;
+      arg3 = &sz3;
+    }
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_write_from_connection(self,size);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_write_from_connection" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      arg2 = amglue_SvU64(ST(1));
+    }
+    result = (gboolean)Device_write_from_connection(arg1,arg2,arg3);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    {
+      SP += argvi; PUTBACK;
+      ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
+      SPAGAIN; SP -= argvi; argvi++;
+    }
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_read_to_connection) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    guint64 arg2 ;
+    guint64 *arg3 = (guint64 *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    guint64 sz3 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    {
+      sz3 = 0;
+      arg3 = &sz3;
+    }
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_read_to_connection(self,size);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_to_connection" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      arg2 = amglue_SvU64(ST(1));
+    }
+    result = (gboolean)Device_read_to_connection(arg1,arg2,arg3);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    {
+      SP += argvi; PUTBACK;
+      ST(argvi) = sv_2mortal(amglue_newSVu64(*arg3));
+      SPAGAIN; SP -= argvi; argvi++;
+    }
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_property_list) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    GSList *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_property_list(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_list" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (GSList *)Device_property_list(arg1);
+    {
+      GSList *iter;
+      
+      /* Count the DeviceProperties */
+      EXTEND(SP, g_slist_length(result)); /* make room for return values */
+      
+      /* Note that we set ST(argvi) several times. the nature of
+            * SWIG's wrapping is such that incrementing argvi points
+            * ST(argvi) to the next location in perl's argument stack.
+                   */
+      
+      for (iter = result; iter; iter = g_slist_next(iter)) {
+        DeviceProperty *prop = iter->data;
+        HV *hash = newHV();
+        SV *rv = newRV_noinc((SV *)hash);
+        
+        hv_store(hash, "name", 4,
+          newSVpv(prop->base->name, 0), 0);
+        hv_store(hash, "description", 11,
+          newSVpv(prop->base->description, 0), 0);
+        hv_store(hash, "access", 6,
+          newSViv(prop->access), 0);
+        ST(argvi) = sv_2mortal(rv);
+        argvi++;
+      }
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_property_get) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
+    GValue *arg3 = (GValue *) 0 ;
+    PropertySurety *arg4 = (PropertySurety *) 0 ;
+    PropertySource *arg5 = (PropertySource *) 0 ;
+    gboolean *arg6 = (gboolean *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    GValue val3 ;
+    PropertySurety surety3 ;
+    PropertySource source3 ;
+    gboolean found3 ;
+    int argvi = 0;
+    dXSARGS;
+    
+    {
+      memset(&val3, 0, sizeof(val3));
+      arg3 = &val3;
+      if (GIMME_V == G_ARRAY) {
+        arg4 = &surety3;
+        arg5 = &source3;
+      }
+      arg6 = &found3;
+    }
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_property_get(self,pbase,surety,source,val_found);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_get" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      char *pname = NULL;
+      
+      if (SvPOK(ST(1)))
+      pname = SvPV_nolen(ST(1));
+      
+      if (pname)
+      arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
+      else
+      arg2 = NULL;
+    }
+    Device_property_get(arg1,arg2,arg3,arg4,arg5,arg6);
+    ST(argvi) = sv_newmortal();
+    {
+      /* if the result is valid */
+      if (*arg6) {
+        /* move data from arg3 to ST(argvi), somehow, being careful to
+                        * save the perl stack while doing so */
+        SP += argvi; PUTBACK;
+        ST(argvi) = set_sv_from_gvalue(arg3);
+        SPAGAIN; SP -= argvi; argvi++;
+        
+        /* free any memory for the GValue */
+        g_value_unset(arg3);
+        
+        if (GIMME_V == G_ARRAY) {
+          ST(argvi) = newSViv(*arg4);
+          argvi++;
+          ST(argvi) = newSViv(*arg5);
+          argvi++;
+        }
+      }
+      /* otherwise, return nothing */
+    }
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_property_set) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
+    SV *arg3 = (SV *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: Device_property_set(self,pbase,sv);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      char *pname = NULL;
+      
+      if (SvPOK(ST(1)))
+      pname = SvPV_nolen(ST(1));
+      
+      if (pname)
+      arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
+      else
+      arg2 = NULL;
+    }
+    arg3 = ST(2);
+    result = (gboolean)Device_property_set(arg1,arg2,arg3);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_property_set_ex) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
+    SV *arg3 = (SV *) 0 ;
+    PropertySurety arg4 ;
+    PropertySource arg5 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 5) || (items > 5)) {
+      SWIG_croak("Usage: Device_property_set_ex(self,pbase,sv,surety,source);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set_ex" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      char *pname = NULL;
+      
+      if (SvPOK(ST(1)))
+      pname = SvPV_nolen(ST(1));
+      
+      if (pname)
+      arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
+      else
+      arg2 = NULL;
+    }
+    arg3 = ST(2);
+    {
+      if (sizeof(signed int) == 1) {
+        arg4 = amglue_SvI8(ST(3));
+      } else if (sizeof(signed int) == 2) {
+        arg4 = amglue_SvI16(ST(3));
+      } else if (sizeof(signed int) == 4) {
+        arg4 = amglue_SvI32(ST(3));
+      } else if (sizeof(signed int) == 8) {
+        arg4 = amglue_SvI64(ST(3));
+      } else {
+        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
+      }
+    }
+    {
+      if (sizeof(signed int) == 1) {
+        arg5 = amglue_SvI8(ST(4));
+      } else if (sizeof(signed int) == 2) {
+        arg5 = amglue_SvI16(ST(4));
+      } else if (sizeof(signed int) == 4) {
+        arg5 = amglue_SvI32(ST(4));
+      } else if (sizeof(signed int) == 8) {
+        arg5 = amglue_SvI64(ST(4));
+      } else {
+        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
+      }
+    }
+    result = (gboolean)Device_property_set_ex(arg1,arg2,arg3,arg4,arg5);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    
+    
+    
+    
+    XSRETURN(argvi);
+  fail:
+    
+    
+    
+    
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_recycle_file) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    guint arg2 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 2) || (items > 2)) {
+      SWIG_croak("Usage: Device_recycle_file(self,filenum);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_recycle_file" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    {
+      if (sizeof(guint) == 1) {
+        arg2 = amglue_SvU8(ST(1));
+      } else if (sizeof(guint) == 2) {
+        arg2 = amglue_SvU16(ST(1));
+      } else if (sizeof(guint) == 4) {
+        arg2 = amglue_SvU32(ST(1));
+      } else if (sizeof(guint) == 8) {
+        arg2 = amglue_SvU64(ST(1));
+      } else {
         croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
       }
     }
-    result = (dumpfile_t *)Device_seek_file(arg1,arg2);
-    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
+    result = (gboolean)Device_recycle_file(arg1,arg2);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_file) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    int result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_file(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_file" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (int)Device_file(arg1);
+    {
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVi64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_block) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    guint64 result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_block(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = Device_block(arg1);
+    {
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVu64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_in_file) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_in_file(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_in_file" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (gboolean)Device_in_file(arg1);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_device_name) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_device_name(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_device_name" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (char *)Device_device_name(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_access_mode) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    DeviceAccessMode result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_access_mode(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_access_mode" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (DeviceAccessMode)Device_access_mode(arg1);
+    {
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVi64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_is_eof) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_is_eof(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eof" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (gboolean)Device_is_eof(arg1);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_is_eom) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    gboolean result;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_is_eom(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_is_eom" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (gboolean)Device_is_eom(arg1);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
+    }
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_Device_volume_label) {
+  {
+    Device *arg1 = (Device *) 0 ;
+    void *argp1 = 0 ;
+    int res1 = 0 ;
+    int argvi = 0;
+    char *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_volume_label(self);");
+    }
+    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res1)) {
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_label" "', argument " "1"" of type '" "Device *""'"); 
+    }
+    arg1 = (Device *)(argp1);
+    result = (char *)Device_volume_label(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
     XSRETURN(argvi);
   fail:
@@ -2745,32 +3974,25 @@ XS(_wrap_Device_seek_file) {
 }
 
 
-XS(_wrap_Device_seek_block) {
+XS(_wrap_Device_volume_time) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint64 arg2 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    char *result = 0 ;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: Device_seek_block(self,block);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_volume_time(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_seek_block" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_time" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    {
-      arg2 = amglue_SvU64(ST(1));
-    }
-    result = (gboolean)Device_seek_block(arg1,arg2);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
-      argvi++;
-    }
+    result = (char *)Device_volume_time(arg1);
+    ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
     
     XSRETURN(argvi);
   fail:
@@ -2780,138 +4002,101 @@ XS(_wrap_Device_seek_block) {
 }
 
 
-XS(_wrap_Device_read_block) {
+XS(_wrap_Device_status) {
   {
     Device *arg1 = (Device *) 0 ;
-    gpointer arg2 = (gpointer) 0 ;
-    int *arg3 = (int *) 0 ;
-    int result;
     void *argp1 = 0 ;
     int res1 = 0 ;
-    int res2 ;
-    void *argp3 = 0 ;
-    int res3 = 0 ;
     int argvi = 0;
+    DeviceStatusFlags result;
     dXSARGS;
     
-    if ((items < 3) || (items > 3)) {
-      SWIG_croak("Usage: Device_read_block(self,buffer,size);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_status(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_block" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_status" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    res2 = SWIG_ConvertPtr(ST(1),SWIG_as_voidptrptr(&arg2), 0, 0);
-    if (!SWIG_IsOK(res2)) {
-      SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Device_read_block" "', argument " "2"" of type '" "gpointer""'"); 
-    }
-    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_int, 0 |  0 );
-    if (!SWIG_IsOK(res3)) {
-      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Device_read_block" "', argument " "3"" of type '" "int *""'"); 
-    }
-    arg3 = (int *)(argp3);
-    result = (int)Device_read_block(arg1,arg2,arg3);
+    result = (DeviceStatusFlags)Device_status(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVi64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
       argvi++;
     }
     
-    
-    
     XSRETURN(argvi);
   fail:
     
-    
-    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_read_to_fd) {
+XS(_wrap_Device_min_block_size) {
   {
     Device *arg1 = (Device *) 0 ;
-    int arg2 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gsize result;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: Device_read_to_fd(self,fd);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_min_block_size(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_read_to_fd" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_min_block_size" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
+    result = Device_min_block_size(arg1);
     {
-      if (sizeof(signed int) == 1) {
-        arg2 = amglue_SvI8(ST(1));
-      } else if (sizeof(signed int) == 2) {
-        arg2 = amglue_SvI16(ST(1));
-      } else if (sizeof(signed int) == 4) {
-        arg2 = amglue_SvI32(ST(1));
-      } else if (sizeof(signed int) == 8) {
-        arg2 = amglue_SvI64(ST(1));
-      } else {
-        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
-      }
-    }
-    result = (gboolean)Device_read_to_fd(arg1,arg2);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVu64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
       argvi++;
     }
     
-    
     XSRETURN(argvi);
   fail:
     
-    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_property_list) {
+XS(_wrap_Device_max_block_size) {
   {
     Device *arg1 = (Device *) 0 ;
-    DeviceProperty *result = 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gsize result;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_property_list(self);");
+      SWIG_croak("Usage: Device_max_block_size(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_list" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_max_block_size" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
-    result = (DeviceProperty *)Device_property_list(arg1);
+    result = Device_max_block_size(arg1);
     {
-      int i = 0;
-      int len = 0;
-      
-      /* Count the DeviceProperties */
-      while (result[len].base) len++;
-      EXTEND(SP, len); /* make room for return values */
-      
-      /* Note that we set ST(argvi) several times. the nature of
-            * SWIG's wrapping is such that incrementing argvi points
-            * ST(argvi) to the next location in perl's argument stack.
-                   */
-      
-      for (i = 0; i < len ; i++) {
-        ST(argvi) = sv_newmortal(); 
-        sv_setpv(ST(argvi), result[i].base->name); 
-        argvi++;
-      }; 
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVu64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
+      argvi++;
     }
     
     XSRETURN(argvi);
@@ -2922,238 +4107,270 @@ XS(_wrap_Device_property_list) {
 }
 
 
-XS(_wrap_Device_property_get) {
+XS(_wrap_Device_block_size) {
   {
     Device *arg1 = (Device *) 0 ;
-    DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
-    GValue *arg3 = (GValue *) 0 ;
-    gboolean *arg4 = (gboolean *) 0 ;
     void *argp1 = 0 ;
     int res1 = 0 ;
-    GValue val3 ;
-    gboolean found3 ;
     int argvi = 0;
+    gsize result;
     dXSARGS;
     
-    {
-      memset(&val3, 0, sizeof(val3));
-      arg3 = &val3;
-      arg4 = &found3;
-    }
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: Device_property_get(self,pbase,val_found);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_block_size(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_get" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_block_size" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
+    result = Device_block_size(arg1);
     {
-      char *pname = NULL;
-      
-      if (SvPOK(ST(1)))
-      pname = SvPV_nolen(ST(1));
-      
-      if (pname) arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
-      if (!pname || !arg2) {
-        SWIG_exception_fail(SWIG_ValueError, "Invalid property name");
-      }
-    }
-    Device_property_get(arg1,arg2,arg3,arg4);
-    
-    {
-      /* if the result is valid */
-      if (*arg4) {
-        /* move data from arg3 to ST(argvi), somehow */
-        ST(argvi) = set_sv_from_gvalue(arg3);
-        
-        /* free any memory for the GValue */
-        g_value_unset(arg3);
-      } else {
-        /* silently return 'undef', the sentinel for "undefined" */
-        ST(argvi) = sv_newmortal();
-        sv_setsv(ST(argvi), &PL_sv_undef);
-      }
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVu64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
       argvi++;
     }
     
-    
     XSRETURN(argvi);
   fail:
     
-    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_property_set) {
+XS(_wrap_Device_header_block_size) {
   {
     Device *arg1 = (Device *) 0 ;
-    DevicePropertyBase *arg2 = (DevicePropertyBase *) 0 ;
-    SV *arg3 = (SV *) 0 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    gsize result;
     dXSARGS;
     
-    if ((items < 3) || (items > 3)) {
-      SWIG_croak("Usage: Device_property_set(self,pbase,sv);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_header_block_size(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_property_set" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_header_block_size" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
+    result = Device_header_block_size(arg1);
     {
-      char *pname = NULL;
-      
-      if (SvPOK(ST(1)))
-      pname = SvPV_nolen(ST(1));
-      
-      if (pname) arg2 = (DevicePropertyBase *)device_property_get_by_name(pname);
-      if (!pname || !arg2) {
-        SWIG_exception_fail(SWIG_ValueError, "Invalid property name");
-      }
-    }
-    arg3 = ST(2);
-    result = (gboolean)Device_property_set(arg1,arg2,arg3);
-    {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      SV *for_stack;
+      SP += argvi; PUTBACK;
+      for_stack = sv_2mortal(amglue_newSVu64(result));
+      SPAGAIN; SP -= argvi;
+      ST(argvi) = for_stack;
       argvi++;
     }
     
-    
-    
     XSRETURN(argvi);
   fail:
     
-    
-    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_recycle_file) {
+XS(_wrap_Device_volume_header) {
   {
     Device *arg1 = (Device *) 0 ;
-    guint arg2 ;
-    gboolean result;
     void *argp1 = 0 ;
     int res1 = 0 ;
     int argvi = 0;
+    dumpfile_t *result = 0 ;
     dXSARGS;
     
-    if ((items < 2) || (items > 2)) {
-      SWIG_croak("Usage: Device_recycle_file(self,filenum);");
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: Device_volume_header(self);");
     }
     res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
     if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_recycle_file" "', argument " "1"" of type '" "Device *""'"); 
+      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_volume_header" "', argument " "1"" of type '" "Device *""'"); 
     }
     arg1 = (Device *)(argp1);
+    result = (dumpfile_t *)Device_volume_header(arg1);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_dumpfile_t, 0 | SWIG_SHADOW); argvi++ ;
+    
+    XSRETURN(argvi);
+  fail:
+    
+    SWIG_croak_null();
+  }
+}
+
+
+XS(_wrap_rait_device_open_from_children) {
+  {
+    GSList *arg1 = (GSList *) 0 ;
+    int argvi = 0;
+    Device *result = 0 ;
+    dXSARGS;
+    
+    if ((items < 1) || (items > 1)) {
+      SWIG_croak("Usage: rait_device_open_from_children(child_devices);");
+    }
     {
-      if (sizeof(guint) == 1) {
-        arg2 = amglue_SvU8(ST(1));
-      } else if (sizeof(guint) == 2) {
-        arg2 = amglue_SvU16(ST(1));
-      } else if (sizeof(guint) == 4) {
-        arg2 = amglue_SvU32(ST(1));
-      } else if (sizeof(guint) == 8) {
-        arg2 = amglue_SvU64(ST(1));
-      } else {
-        croak("Unexpected guint >64 bits?"); /* should be optimized out unless sizeof(guint) > 8 */
+      AV *av;
+      int i, len;
+      
+      if (!SvROK(ST(0)) || SvTYPE(SvRV(ST(0))) != SVt_PVAV) {
+        SWIG_exception(SWIG_TypeError, "Expected an arrayref");
+      }
+      av = (AV *)SvRV(ST(0));
+      
+      arg1 = NULL;
+      len = av_len(av);
+      for (i = 0; i <= len; i++) {
+        SV **elt = av_fetch(av, i, 0);
+        Device *d;
+        
+        if (elt && !SvOK(*elt)) {
+          arg1 = g_slist_append(arg1, NULL); /* 'undef' => NULL */
+        } else if (!elt || SWIG_ConvertPtr(*elt, (void **)&d, SWIGTYPE_p_Device, 0) == -1) {
+          SWIG_exception(SWIG_TypeError, "array member is not a Device");
+        } else {
+          arg1 = g_slist_append(arg1, d);
+        }
       }
     }
-    result = (gboolean)Device_recycle_file(arg1,arg2);
+    result = (Device *)rait_device_open_from_children(arg1);
+    ST(argvi) = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Device, SWIG_OWNER | SWIG_SHADOW); argvi++ ;
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
-      argvi++;
+      g_slist_free(arg1);
     }
-    
     XSRETURN(argvi);
   fail:
-    
+    {
+      g_slist_free(arg1);
+    }
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_Device_set_startup_properties_from_config) {
+XS(_wrap_write_random_to_device) {
   {
-    Device *arg1 = (Device *) 0 ;
-    void *argp1 = 0 ;
-    int res1 = 0 ;
+    guint32 arg1 ;
+    size_t arg2 ;
+    Device *arg3 = (Device *) 0 ;
+    void *argp3 = 0 ;
+    int res3 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: Device_set_startup_properties_from_config(self);");
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: write_random_to_device(seed,length,device);");
     }
-    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );
-    if (!SWIG_IsOK(res1)) {
-      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Device_set_startup_properties_from_config" "', argument " "1"" of type '" "Device *""'"); 
+    {
+      arg1 = amglue_SvU32(ST(0));
+    }
+    {
+      if (sizeof(size_t) == 1) {
+        arg2 = amglue_SvU8(ST(1));
+      } else if (sizeof(size_t) == 2) {
+        arg2 = amglue_SvU16(ST(1));
+      } else if (sizeof(size_t) == 4) {
+        arg2 = amglue_SvU32(ST(1));
+      } else if (sizeof(size_t) == 8) {
+        arg2 = amglue_SvU64(ST(1));
+      } else {
+        croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
+      }
+    }
+    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "write_random_to_device" "', argument " "3"" of type '" "Device *""'"); 
+    }
+    arg3 = (Device *)(argp3);
+    result = (gboolean)write_random_to_device(arg1,arg2,arg3);
+    {
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
+      argvi++;
     }
-    arg1 = (Device *)(argp1);
-    Device_set_startup_properties_from_config(arg1);
     
     
     XSRETURN(argvi);
   fail:
     
+    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_IS_WRITABLE_ACCESS_MODE) {
+XS(_wrap_verify_random_from_device) {
   {
-    DeviceAccessMode arg1 ;
-    gboolean result;
+    guint32 arg1 ;
+    size_t arg2 ;
+    Device *arg3 = (Device *) 0 ;
+    void *argp3 = 0 ;
+    int res3 = 0 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
-    if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: IS_WRITABLE_ACCESS_MODE(mode);");
+    if ((items < 3) || (items > 3)) {
+      SWIG_croak("Usage: verify_random_from_device(seed,length,device);");
     }
     {
-      if (sizeof(signed int) == 1) {
-        arg1 = amglue_SvI8(ST(0));
-      } else if (sizeof(signed int) == 2) {
-        arg1 = amglue_SvI16(ST(0));
-      } else if (sizeof(signed int) == 4) {
-        arg1 = amglue_SvI32(ST(0));
-      } else if (sizeof(signed int) == 8) {
-        arg1 = amglue_SvI64(ST(0));
+      arg1 = amglue_SvU32(ST(0));
+    }
+    {
+      if (sizeof(size_t) == 1) {
+        arg2 = amglue_SvU8(ST(1));
+      } else if (sizeof(size_t) == 2) {
+        arg2 = amglue_SvU16(ST(1));
+      } else if (sizeof(size_t) == 4) {
+        arg2 = amglue_SvU32(ST(1));
+      } else if (sizeof(size_t) == 8) {
+        arg2 = amglue_SvU64(ST(1));
       } else {
-        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
+        croak("Unexpected size_t >64 bits?"); /* should be optimized out unless sizeof(size_t) > 8 */
       }
     }
-    result = (gboolean)IS_WRITABLE_ACCESS_MODE(arg1);
+    res3 = SWIG_ConvertPtr(ST(2), &argp3,SWIGTYPE_p_Device, 0 |  0 );
+    if (!SWIG_IsOK(res3)) {
+      SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "verify_random_from_device" "', argument " "3"" of type '" "Device *""'"); 
+    }
+    arg3 = (Device *)(argp3);
+    result = (gboolean)verify_random_from_device(arg1,arg2,arg3);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
+    
     XSRETURN(argvi);
   fail:
     
+    
     SWIG_croak_null();
   }
 }
 
 
-XS(_wrap_feature_support_flags_is_valid) {
+XS(_wrap_IS_WRITABLE_ACCESS_MODE) {
   {
-    FeatureSupportFlags arg1 ;
-    gboolean result;
+    DeviceAccessMode arg1 ;
     int argvi = 0;
+    gboolean result;
     dXSARGS;
     
     if ((items < 1) || (items > 1)) {
-      SWIG_croak("Usage: feature_support_flags_is_valid(FeatureSupportFlags);");
+      SWIG_croak("Usage: IS_WRITABLE_ACCESS_MODE(mode);");
     }
     {
       if (sizeof(signed int) == 1) {
@@ -3168,9 +4385,12 @@ XS(_wrap_feature_support_flags_is_valid) {
         g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
       }
     }
-    result = (gboolean)feature_support_flags_is_valid(arg1);
+    result = (gboolean)IS_WRITABLE_ACCESS_MODE(arg1);
     {
-      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
+      if (result)
+      ST(argvi) = &PL_sv_yes;
+      else
+      ST(argvi) = &PL_sv_no;
       argvi++;
     }
     
@@ -3187,20 +4407,28 @@ XS(_wrap_feature_support_flags_is_valid) {
 
 static swig_type_info _swigt__p_Device = {"_p_Device", "struct Device *|Device *", 0, 0, (void*)"Amanda::Device::Device", 0};
 static swig_type_info _swigt__p_DevicePropertyBase = {"_p_DevicePropertyBase", "DevicePropertyBase *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_DirectTCPAddr = {"_p_DirectTCPAddr", "DirectTCPAddr *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_DirectTCPConnection = {"_p_DirectTCPConnection", "struct DirectTCPConnection *|DirectTCPConnection *", 0, 0, (void*)"Amanda::Device::DirectTCPConnection", 0};
+static swig_type_info _swigt__p_GSList = {"_p_GSList", "GSList *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_GValue = {"_p_GValue", "GValue *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_a_STRMAX__char = {"_p_a_STRMAX__char", "char (*)[STRMAX]|string_t *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_char = {"_p_char", "gchar *|char *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_double = {"_p_double", "double *|gdouble *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Types::dumpfile_t", 0};
+static swig_type_info _swigt__p_dumpfile_t = {"_p_dumpfile_t", "dumpfile_t *", 0, 0, (void*)"Amanda::Header::Header", 0};
 static swig_type_info _swigt__p_float = {"_p_float", "float *|gfloat *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_guint = {"_p_guint", "guint *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_guint32 = {"_p_guint32", "guint32 *", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_guint64 = {"_p_guint64", "guint64 *", 0, 0, (void*)0, 0};
-static swig_type_info _swigt__p_int = {"_p_int", "int *|ConcurrencyParadigm *|filetype_t *|SizeAccuracy *|StreamingRequirement *|gboolean *|DeviceAccessMode *|MediaAccessMode *|FeatureSupportFlags *|ReadLabelStatusFlags *|PropertyPhaseFlags *|PropertyAccessFlags *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_int = {"_p_int", "int *|PropertySurety *|ConcurrencyParadigm *|filetype_t *|PropertySource *|StreamingRequirement *|gboolean *|DeviceAccessMode *|MediaAccessMode *|DeviceStatusFlags *|PropertyPhaseFlags *|PropertyAccessFlags *", 0, 0, (void*)0, 0};
+static swig_type_info _swigt__p_p_DirectTCPAddr = {"_p_p_DirectTCPAddr", "DirectTCPAddr **", 0, 0, (void*)0, 0};
 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "guchar *|unsigned char *", 0, 0, (void*)0, 0};
 
 static swig_type_info *swig_type_initial[] = {
   &_swigt__p_Device,
   &_swigt__p_DevicePropertyBase,
+  &_swigt__p_DirectTCPAddr,
+  &_swigt__p_DirectTCPConnection,
+  &_swigt__p_GSList,
   &_swigt__p_GValue,
   &_swigt__p_a_STRMAX__char,
   &_swigt__p_char,
@@ -3208,13 +4436,18 @@ static swig_type_info *swig_type_initial[] = {
   &_swigt__p_dumpfile_t,
   &_swigt__p_float,
   &_swigt__p_guint,
+  &_swigt__p_guint32,
   &_swigt__p_guint64,
   &_swigt__p_int,
+  &_swigt__p_p_DirectTCPAddr,
   &_swigt__p_unsigned_char,
 };
 
 static swig_cast_info _swigc__p_Device[] = {  {&_swigt__p_Device, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_DevicePropertyBase[] = {  {&_swigt__p_DevicePropertyBase, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_DirectTCPAddr[] = {  {&_swigt__p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_DirectTCPConnection[] = {  {&_swigt__p_DirectTCPConnection, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_GSList[] = {  {&_swigt__p_GSList, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_GValue[] = {  {&_swigt__p_GValue, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_a_STRMAX__char[] = {  {&_swigt__p_a_STRMAX__char, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
@@ -3222,13 +4455,18 @@ static swig_cast_info _swigc__p_double[] = {  {&_swigt__p_double, 0, 0, 0},{0, 0
 static swig_cast_info _swigc__p_dumpfile_t[] = {  {&_swigt__p_dumpfile_t, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_float[] = {  {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_guint[] = {  {&_swigt__p_guint, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_guint32[] = {  {&_swigt__p_guint32, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_guint64[] = {  {&_swigt__p_guint64, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
+static swig_cast_info _swigc__p_p_DirectTCPAddr[] = {  {&_swigt__p_p_DirectTCPAddr, 0, 0, 0},{0, 0, 0, 0}};
 static swig_cast_info _swigc__p_unsigned_char[] = {  {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
 
 static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_Device,
   _swigc__p_DevicePropertyBase,
+  _swigc__p_DirectTCPAddr,
+  _swigc__p_DirectTCPConnection,
+  _swigc__p_GSList,
   _swigc__p_GValue,
   _swigc__p_a_STRMAX__char,
   _swigc__p_char,
@@ -3236,8 +4474,10 @@ static swig_cast_info *swig_cast_initial[] = {
   _swigc__p_dumpfile_t,
   _swigc__p_float,
   _swigc__p_guint,
+  _swigc__p_guint32,
   _swigc__p_guint64,
   _swigc__p_int,
+  _swigc__p_p_DirectTCPAddr,
   _swigc__p_unsigned_char,
 };
 
@@ -3254,37 +4494,58 @@ static swig_variable_info swig_variables[] = {
 {0,0,0,0}
 };
 static swig_command_info swig_commands[] = {
-{"Amanda::Devicec::Device_file_get", _wrap_Device_file_get},
-{"Amanda::Devicec::Device_block_get", _wrap_Device_block_get},
-{"Amanda::Devicec::Device_in_file_get", _wrap_Device_in_file_get},
-{"Amanda::Devicec::Device_device_name_get", _wrap_Device_device_name_get},
-{"Amanda::Devicec::Device_access_mode_get", _wrap_Device_access_mode_get},
-{"Amanda::Devicec::Device_is_eof_get", _wrap_Device_is_eof_get},
-{"Amanda::Devicec::Device_volume_label_get", _wrap_Device_volume_label_get},
-{"Amanda::Devicec::Device_volume_time_get", _wrap_Device_volume_time_get},
+{"Amanda::Devicec::delete_DirectTCPConnection", _wrap_delete_DirectTCPConnection},
+{"Amanda::Devicec::DirectTCPConnection_close", _wrap_DirectTCPConnection_close},
+{"Amanda::Devicec::new_DirectTCPConnection", _wrap_new_DirectTCPConnection},
+{"Amanda::Devicec::unaliased_name", _wrap_unaliased_name},
 {"Amanda::Devicec::new_Device", _wrap_new_Device},
 {"Amanda::Devicec::delete_Device", _wrap_delete_Device},
+{"Amanda::Devicec::Device_configure", _wrap_Device_configure},
+{"Amanda::Devicec::Device_error", _wrap_Device_error},
+{"Amanda::Devicec::Device_status_error", _wrap_Device_status_error},
+{"Amanda::Devicec::Device_error_or_status", _wrap_Device_error_or_status},
 {"Amanda::Devicec::Device_read_label", _wrap_Device_read_label},
 {"Amanda::Devicec::Device_start", _wrap_Device_start},
 {"Amanda::Devicec::Device_finish", _wrap_Device_finish},
 {"Amanda::Devicec::Device_start_file", _wrap_Device_start_file},
-{"Amanda::Devicec::Device_write_min_size", _wrap_Device_write_min_size},
-{"Amanda::Devicec::Device_write_max_size", _wrap_Device_write_max_size},
-{"Amanda::Devicec::Device_read_max_size", _wrap_Device_read_max_size},
 {"Amanda::Devicec::Device_write_block", _wrap_Device_write_block},
-{"Amanda::Devicec::Device_write_from_fd", _wrap_Device_write_from_fd},
 {"Amanda::Devicec::Device_finish_file", _wrap_Device_finish_file},
 {"Amanda::Devicec::Device_seek_file", _wrap_Device_seek_file},
 {"Amanda::Devicec::Device_seek_block", _wrap_Device_seek_block},
 {"Amanda::Devicec::Device_read_block", _wrap_Device_read_block},
-{"Amanda::Devicec::Device_read_to_fd", _wrap_Device_read_to_fd},
+{"Amanda::Devicec::Device_erase", _wrap_Device_erase},
+{"Amanda::Devicec::Device_eject", _wrap_Device_eject},
+{"Amanda::Devicec::Device_directtcp_supported", _wrap_Device_directtcp_supported},
+{"Amanda::Devicec::Device_listen", _wrap_Device_listen},
+{"Amanda::Devicec::Device_accept", _wrap_Device_accept},
+{"Amanda::Devicec::Device_connect", _wrap_Device_connect},
+{"Amanda::Devicec::Device_use_connection", _wrap_Device_use_connection},
+{"Amanda::Devicec::Device_write_from_connection", _wrap_Device_write_from_connection},
+{"Amanda::Devicec::Device_read_to_connection", _wrap_Device_read_to_connection},
 {"Amanda::Devicec::Device_property_list", _wrap_Device_property_list},
 {"Amanda::Devicec::Device_property_get", _wrap_Device_property_get},
 {"Amanda::Devicec::Device_property_set", _wrap_Device_property_set},
+{"Amanda::Devicec::Device_property_set_ex", _wrap_Device_property_set_ex},
 {"Amanda::Devicec::Device_recycle_file", _wrap_Device_recycle_file},
-{"Amanda::Devicec::Device_set_startup_properties_from_config", _wrap_Device_set_startup_properties_from_config},
+{"Amanda::Devicec::Device_file", _wrap_Device_file},
+{"Amanda::Devicec::Device_block", _wrap_Device_block},
+{"Amanda::Devicec::Device_in_file", _wrap_Device_in_file},
+{"Amanda::Devicec::Device_device_name", _wrap_Device_device_name},
+{"Amanda::Devicec::Device_access_mode", _wrap_Device_access_mode},
+{"Amanda::Devicec::Device_is_eof", _wrap_Device_is_eof},
+{"Amanda::Devicec::Device_is_eom", _wrap_Device_is_eom},
+{"Amanda::Devicec::Device_volume_label", _wrap_Device_volume_label},
+{"Amanda::Devicec::Device_volume_time", _wrap_Device_volume_time},
+{"Amanda::Devicec::Device_status", _wrap_Device_status},
+{"Amanda::Devicec::Device_min_block_size", _wrap_Device_min_block_size},
+{"Amanda::Devicec::Device_max_block_size", _wrap_Device_max_block_size},
+{"Amanda::Devicec::Device_block_size", _wrap_Device_block_size},
+{"Amanda::Devicec::Device_header_block_size", _wrap_Device_header_block_size},
+{"Amanda::Devicec::Device_volume_header", _wrap_Device_volume_header},
+{"Amanda::Devicec::rait_device_open_from_children", _wrap_rait_device_open_from_children},
+{"Amanda::Devicec::write_random_to_device", _wrap_write_random_to_device},
+{"Amanda::Devicec::verify_random_from_device", _wrap_verify_random_from_device},
 {"Amanda::Devicec::IS_WRITABLE_ACCESS_MODE", _wrap_IS_WRITABLE_ACCESS_MODE},
-{"Amanda::Devicec::feature_support_flags_is_valid", _wrap_feature_support_flags_is_valid},
 {0,0}
 };
 /* -----------------------------------------------------------------------------
@@ -3344,7 +4605,7 @@ SWIGRUNTIME void
 SWIG_InitializeModule(void *clientdata) {
   size_t i;
   swig_module_info *module_head, *iter;
-  int found;
+  int found, init;
   
   clientdata = clientdata;
   
@@ -3354,6 +4615,9 @@ SWIG_InitializeModule(void *clientdata) {
     swig_module.type_initial = swig_type_initial;
     swig_module.cast_initial = swig_cast_initial;
     swig_module.next = &swig_module;
+    init = 1;
+  } else {
+    init = 0;
   }
   
   /* Try and load any already created modules */
@@ -3382,6 +4646,12 @@ SWIG_InitializeModule(void *clientdata) {
     module_head->next = &swig_module;
   }
   
+  /* When multiple interpeters are used, a module could have already been initialized in
+       a different interpreter, but not yet have a pointer in this interpreter.
+       In this case, we do not want to continue adding types... everything should be
+       set up already */
+  if (init == 0) return;
+  
   /* Now work on filling in swig_module.types */
 #ifdef SWIGRUNTIME_DEBUG
   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
@@ -3535,7 +4805,7 @@ XS(SWIG_init) {
   /* Install variables */
   for (i = 0; swig_variables[i].name; i++) {
     SV *sv;
-    sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2);
+    sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
     if (swig_variables[i].type) {
       SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
     } else {
@@ -3547,7 +4817,7 @@ XS(SWIG_init) {
   /* Install constant */
   for (i = 0; swig_constants[i].type; i++) {
     SV *sv;
-    sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2);
+    sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
     switch(swig_constants[i].type) {
     case SWIG_INT:
       sv_setiv(sv, (IV) swig_constants[i].lvalue);
@@ -3574,285 +4844,236 @@ XS(SWIG_init) {
   /* Initialize the Device API on load */
   device_api_init();
   
+  SWIG_TypeClientData(SWIGTYPE_p_DirectTCPConnection, (void*) "Amanda::Device::DirectTCPConnection");
   SWIG_TypeClientData(SWIGTYPE_p_Device, (void*) "Amanda::Device::Device");
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_NULL", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_NULL", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_NULL)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_APPEND", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "ACCESS_APPEND", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(ACCESS_APPEND)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_SUCCESS", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_SUCCESS)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_SUCCESS", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_SUCCESS)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_DEVICE_MISSING", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_DEVICE_MISSING)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_ERROR", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_ERROR)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_DEVICE_ERROR", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_DEVICE_ERROR)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_DEVICE_BUSY", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_DEVICE_BUSY)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_VOLUME_MISSING", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_VOLUME_MISSING)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_MISSING", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_MISSING)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_VOLUME_UNLABELED", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_VOLUME_UNLABELED)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_UNLABELED", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_UNLABELED)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_VOLUME_ERROR", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_VOLUME_ERROR)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_VOLUME_ERROR", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_VOLUME_ERROR)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "READ_LABEL_STATUS_FLAGS_MAX", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(READ_LABEL_STATUS_FLAGS_MAX)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "DEVICE_STATUS_FLAGS_MAX", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(DEVICE_STATUS_FLAGS_MAX)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BEFORE_START", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BEFORE_START)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_BETWEEN_FILE_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_INSIDE_FILE_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MAX", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MAX", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MAX)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MASK", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_MASK", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_MASK)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_SHIFT", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_PHASE_SHIFT", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_PHASE_SHIFT)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BEFORE_START", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BEFORE_START)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_BETWEEN_FILE_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_INSIDE_FILE_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BEFORE_START", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BEFORE_START", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BEFORE_START)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_BETWEEN_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_BETWEEN_FILE_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_INSIDE_FILE_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_INSIDE_FILE_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_MASK", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_GET_MASK", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_GET_MASK)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_MASK", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_ACCESS_SET_MASK", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_ACCESS_SET_MASK)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_EXCLUSIVE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_EXCLUSIVE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_EXCLUSIVE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_SHARED_READ", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_SHARED_READ", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_SHARED_READ)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_RANDOM_ACCESS", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "CONCURRENCY_PARADIGM_RANDOM_ACCESS", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(CONCURRENCY_PARADIGM_RANDOM_ACCESS)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_NONE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_NONE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_NONE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_DESIRED", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_DESIRED", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_DESIRED)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_REQUIRED", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "STREAMING_REQUIREMENT_REQUIRED", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(STREAMING_REQUIREMENT_REQUIRED)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_ONLY", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_ONLY", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_ONLY)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WORM", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WORM", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WORM)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_WRITE", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_READ_WRITE", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_READ_WRITE)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WRITE_ONLY", TRUE | 0x2);
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "MEDIA_ACCESS_MODE_WRITE_ONLY", TRUE | 0x2 | GV_ADDMULTI);
     sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(MEDIA_ACCESS_MODE_WRITE_ONLY)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "SIZE_ACCURACY_UNKNOWN", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SIZE_ACCURACY_UNKNOWN)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "SIZE_ACCURACY_ESTIMATE", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SIZE_ACCURACY_ESTIMATE)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "SIZE_ACCURACY_REAL", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(SIZE_ACCURACY_REAL)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_STATUS_ENABLED", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_STATUS_ENABLED)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_STATUS_DISABLED", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_STATUS_DISABLED)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SURETY_BAD", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SURETY_BAD)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SURETY_GOOD", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SURETY_GOOD)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SOURCE_DEFAULT", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SOURCE_DEFAULT)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SOURCE_DETECTED", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SOURCE_DETECTED)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SOURCE_USER", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SOURCE_USER)));
-    SvREADONLY_on(sv);
-  } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SUPPORT_FLAGS_MAX", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SUPPORT_FLAGS_MAX)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_BAD", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_BAD)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SUPPORT_FLAGS_MASK", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SUPPORT_FLAGS_MASK)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SURETY_GOOD", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SURETY_GOOD)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SUPPORT_FLAGS_STATUS_MASK", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SUPPORT_FLAGS_STATUS_MASK)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DEFAULT", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DEFAULT)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SUPPORT_FLAGS_SURETY_MASK", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SUPPORT_FLAGS_SURETY_MASK)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_DETECTED", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_DETECTED)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
-  /*@SWIG:/usr/share/swig/1.3.33/perl5/perltypemaps.swg,64,%set_constant@*/ do {
-    SV *sv = get_sv((char*) SWIG_prefix "FEATURE_SUPPORT_FLAGS_SOURCE_MASK", TRUE | 0x2);
-    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(FEATURE_SUPPORT_FLAGS_SOURCE_MASK)));
+  /*@SWIG:/usr/share/swig/2.0.4/perl5/perltypemaps.swg,65,%set_constant@*/ do {
+    SV *sv = get_sv((char*) SWIG_prefix "PROPERTY_SOURCE_USER", TRUE | 0x2 | GV_ADDMULTI);
+    sv_setsv(sv, SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(PROPERTY_SOURCE_USER)));
     SvREADONLY_on(sv);
   } while(0) /*@SWIG@*/;
   ST(0) = &PL_sv_yes;