device.c

开源备份软件源码 AMANDA, the Advanced Maryland Automatic Network Disk Archiver, is a backup system that a

	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;
	    }
	}
    }

    /* simple types that can be constructed with sv_set*v */
    sv = sv_newmortal();
    switch (fundamental) {
	case G_TYPE_CHAR:
	    sv_setiv(sv, g_value_get_char(value));
	    break;

	case G_TYPE_UCHAR:
	    sv_setuv(sv, g_value_get_uchar(value));
	    break;

	case G_TYPE_BOOLEAN:
	    sv_setiv(sv, g_value_get_boolean(value));
	    break;

	case G_TYPE_INT:
	    sv_setiv(sv, g_value_get_int(value));
	    break;

	case G_TYPE_UINT:
	    sv_setuv(sv, g_value_get_uint(value));
	    break;

	case G_TYPE_FLOAT:
	    sv_setnv(sv, g_value_get_float(value));
	    break;

	case G_TYPE_DOUBLE:
	    sv_setnv(sv, g_value_get_double(value));
	    break;

	case G_TYPE_STRING:
	    sv_setpv(sv, g_value_get_string(value));
	    break;

	case G_TYPE_ENUM:
	    sv_setiv(sv, g_value_get_enum(value));
	    break;

	case G_TYPE_FLAGS:
	    sv_setiv(sv, g_value_get_flags(value));
	    break;

	/* Unsupported */
	default:
	case G_TYPE_POINTER:
	case G_TYPE_INTERFACE:
	case G_TYPE_OBJECT:
	case G_TYPE_PARAM:
	    warn("Unsupported fundamental property type #%d", fundamental);
	    sv_setsv(sv, &PL_sv_undef);
	    break;
    }

    return sv;
}

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;

	case G_TYPE_BOOLEAN:
	    if (!SvIOK(sv)) return FALSE;
	    g_value_set_boolean(value, SvIV(sv));
	    break;

	case G_TYPE_INT:
	    g_value_set_int(value, amglue_SvI32(sv));
	    break;

	case G_TYPE_UINT:
	    g_value_set_uint(value, amglue_SvU32(sv));
	    break;

	case G_TYPE_LONG:
	    g_value_set_int64(value, amglue_SvI64(sv));
	    break;

	case G_TYPE_ULONG:
	    g_value_set_uint64(value, amglue_SvU64(sv));
	    break;

	case G_TYPE_INT64:
	    g_value_set_int64(value, amglue_SvI64(sv));
	    break;

	case G_TYPE_UINT64:
	    g_value_set_uint64(value, amglue_SvU64(sv));
	    break;

	case G_TYPE_FLOAT:
	    if (!SvNOK(sv)) return FALSE;
	    g_value_set_float(value, SvNV(sv));
	    break;

	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;

	case G_TYPE_ENUM: 
	    if (!SvIOK(sv)) return FALSE;
	    g_value_set_enum(value, SvIV(sv));
	    break;

	case G_TYPE_FLAGS:
	    if (!SvIOK(sv)) return FALSE;
	    g_value_set_flags(value, SvIV(sv));
	    break;

	/* 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;
    }

    return TRUE;
}



SWIGINTERNINLINE SV *
SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
  SV *obj = sv_newmortal();
  if (carray) {
    if (size && (carray[size - 1] == 0)) {
      sv_setpv(obj, carray);
    } else {
      char *tmp = (char *)malloc((size + 1)*sizeof(char));
      memcpy(tmp, carray, size);
      tmp[size] = 0;
      sv_setpv(obj, tmp);
      free((char*)tmp);
    }
  } else {
    sv_setsv(obj, &PL_sv_undef);
  }
  return obj;
}


SWIGINTERNINLINE SV * 
SWIG_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


SWIGINTERN swig_type_info*
SWIG_pchar_descriptor(void)
{
  static int init = 0;
  static swig_type_info* info = 0;
  if (!init) {
    info = SWIG_TypeQuery("_p_char");
    init = 1;
  }
  return info;
}


SWIGINTERN int
SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
{
  if (SvPOK(obj)) {
    STRLEN len = 0;
    char *cstr = SvPV(obj, len); 
    size_t size = len + 1;
    if (cptr)  {
      if (alloc) {
	if (*alloc == SWIG_NEWOBJ) {
	  *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
	} else {
	  *cptr = cstr;
	  *alloc = SWIG_OLDOBJ;
	}
      }
    }
    if (psize) *psize = size;
    return SWIG_OK;
  } else {
    swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
    if (pchar_descriptor) {
      char* vptr = 0; 
      if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
	if (cptr) *cptr = vptr;
	if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
	if (alloc) *alloc = SWIG_OLDOBJ;
	return SWIG_OK;
      }
    }
  }
  return SWIG_TypeError;
}




SWIGINTERN Device *new_Device(char *device_name){
	    return device_open(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>
#ifndef LLONG_MIN
# define LLONG_MIN	LONG_LONG_MIN
#endif
#ifndef LLONG_MAX
# define LLONG_MAX	LONG_LONG_MAX
#endif
#ifndef ULLONG_MAX
# define ULLONG_MAX	ULONG_LONG_MAX
#endif


SWIGINTERN int
SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
{
  if (SvNIOK(obj)) {
    if (val) *val = SvNV(obj);
    return SWIG_OK;
  } else if (SvIOK(obj)) {
    if (val) *val = (double) SvIV(obj);
    return SWIG_AddCast(SWIG_OK);
  } else {
    const char *nptr = SvPV(obj, PL_na);
    if (nptr) {
      char *endptr;
      double v = strtod(nptr, &endptr);
      if (errno == ERANGE) {
	errno = 0;
	return SWIG_OverflowError;
      } else {
	if (*endptr == '\0') {
	  if (val) *val = v;
	  return SWIG_Str2NumCast(SWIG_OK);
	}
      }
    }
  }
  return SWIG_TypeError;
}


#include <float.h>


#include <math.h>


SWIGINTERNINLINE int
SWIG_CanCastAsInteger(double *d, double min, double max) {
  double x = *d;
  if ((min <= x && x <= max)) {
   double fx = floor(x);
   double cx = ceil(x);
   double rd =  ((x - fx) < 0.5) ? fx : cx; /* simple rint */
   if ((errno == EDOM) || (errno == ERANGE)) {
     errno = 0;
   } else {
     double summ, reps, diff;
     if (rd < x) {
       diff = x - rd;
     } else if (rd > x) {
       diff = rd - x;
     } else {
       return 1;
     }
     summ = rd + x;
     reps = diff/summ;
     if (reps < 8*DBL_EPSILON) {
       *d = rd;
       return 1;
     }
   }
  }
  return 0;
}


SWIGINTERN int
SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
{
  if (SvIOK(obj)) {
    if (val) *val = SvIV(obj);
    return SWIG_OK;
  } else {
    int dispatch = 0;
    const char *nptr = SvPV(obj, PL_na);
    if (nptr) {
      char *endptr;
      long v = strtol(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, LONG_MIN, LONG_MAX)) {
	if (val) *val = (long)(d);
	return res;
      }
    }
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
{
  long v;
  int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
  if (SWIG_IsOK(res)) {
    if ((v < INT_MIN || v > INT_MAX)) {
      return SWIG_OverflowError;
    } else {
      if (val) *val = (int)(v);
    }
  }  
  return res;
}

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){
	    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_finish_file(Device *self){
	    return device_finish_file(self);
	}
SWIGINTERN dumpfile_t *Device_seek_file(Device *self,guint file){
	    return device_seek_file(self, file);
	}
SWIGINTERN gboolean Device_seek_block(Device *self,guint64 block){
	    return device_seek_block(self, 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 DeviceProperty 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 gboolean Device_property_set(Device *self,DevicePropertyBase *pbase,SV *sv){
	    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(self, pbase->ID, &gval))
		goto fail;

	    g_value_unset(&gval);
	    return TRUE;
	fail:
	    g_value_unset(&gval);
	    return FALSE;
	}
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);
	}

SWIGINTERNINLINE SV *
SWIG_From_long  SWIG_PERL_DECL_ARGS_1(long value)
{    
  SV *obj = sv_newmortal();
  sv_setiv(obj, (IV) value);
  return obj;
}


SWIGINTERNINLINE SV *
SWIG_From_int  SWIG_PERL_DECL_ARGS_1(int value)
{    
  return SWIG_From_long  SWIG_PERL_CALL_ARGS_1(value);
}

#ifdef PERL_OBJECT
#define MAGIC_CLASS _wrap_Amanda::Device_var::
class _wrap_Amanda::Device_var : public CPerlObj {
public:
#else
#define MAGIC_CLASS
#endif
SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
    MAGIC_PPERL
    croak("Value is read-only.");
    return 0;
}


#ifdef PERL_OBJECT
};
#endif

#ifdef __cplusplus
extern "C" {
#endif
XS(_wrap_Device_file_get) {
  {
    Device *arg1 = (Device *) 0 ;
    int result;
    void *argp1 = 0 ;
    int res1 = 0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) {
      SWIG_croak("Usage: Device_file_get(self);");
    }
    res1 = SWIG_ConvertPtr(ST(0), &argp1,SWIGTYPE_p_Device, 0 |  0 );