config.c

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

    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_chunker""' of type '""int""'");
    }
    debug_chunker = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_chunker_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_chunker)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_taper_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_taper""' of type '""int""'");
    }
    debug_taper = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_taper_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_taper)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_selfcheck_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_selfcheck""' of type '""int""'");
    }
    debug_selfcheck = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_selfcheck_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_selfcheck)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_sendsize_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_sendsize""' of type '""int""'");
    }
    debug_sendsize = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_sendsize_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_sendsize)))  ;
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_sendbackup_set(pTHX_ SV* sv, MAGIC * SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  {
    int val;
    int res = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(sv, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""debug_sendbackup""' of type '""int""'");
    }
    debug_sendbackup = (int)(val);
  }
fail:
  return 1;
}


SWIGCLASS_STATIC int _wrap_debug_sendbackup_get(pTHX_ SV *sv, MAGIC *SWIGUNUSEDPARM(mg)) {
  MAGIC_PPERL
  sv_setsv(sv,SWIG_From_int  SWIG_PERL_CALL_ARGS_1((int)(debug_sendbackup)))  ;
  return 1;
}




#ifdef PERL_OBJECT
};
#endif

#ifdef __cplusplus
extern "C" {
#endif
XS(_wrap_getconf) {
  {
    confparm_key arg1 ;
    val_t *result = 0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) {
      SWIG_croak("Usage: getconf(key);");
    }
    {
      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));
      } else {
        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
      }
    }
    result = (val_t *)getconf(arg1);
    {
      switch (result->type) {
        case CONFTYPE_RATE: {
          ST(argvi)= sv_newmortal();
          sv_setnv(ST(argvi), val_t__rate(result)[0]);
          argvi++;
          
          ST(argvi)= sv_newmortal();
          sv_setnv(ST(argvi), val_t__rate(result)[1]);
          argvi++;
          break;
        }
        
        case CONFTYPE_INTRANGE: {
          ST(argvi)= sv_newmortal();
          sv_setiv(ST(argvi), val_t__intrange(result)[0]);
          argvi++;
          
          ST(argvi)= sv_newmortal();
          sv_setiv(ST(argvi), val_t__intrange(result)[1]);
          argvi++;
          break;
          break;
        }
        
        case CONFTYPE_EXINCLUDE: {
          /* exincludes are represented in perl as {
          	     *	'list' : [ 'list1', 'list2', ..],
          	     *	'file' : [ 'file1', 'file2', ..],
          	     *	'optional' : 1,
          	     * }
          	     */
          exinclude_t *ei = &val_t__exinclude(result);
          AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
          AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
          SV *optional = sv_newmortal();
          HV *hv;
          sle_t *iter;
          
          /* first set up each of the hash values */
          
          if (ei->sl_list) {
            for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
              av_push(list_entries, newSVpv(iter->name, 0));
            }
          }
          
          if(ei->sl_file) {
            for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
              av_push(file_entries, newSVpv(iter->name, 0));
            }
          }
          
          sv_setiv(optional, ei->optional);
          
          /* now build the hash */
          hv = (HV *)sv_2mortal((SV *)newHV());
          
          hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
          hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
          hv_store(hv, "optional", 8, optional, 0);
          SvREFCNT_inc(optional);
          
          ST(argvi) = sv_2mortal(newRV((SV *)hv));
          argvi++;
          break;
        }
        
      case CONFTYPE_PROPLIST:
        ST(argvi) = sv_2mortal(g_hash_table_to_hashref(val_t__proplist(result)));
        argvi++;
        break;
        
      case CONFTYPE_SIZE:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
        argvi++;
        break;
        
      case CONFTYPE_AM64:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__am64(result)));
        argvi++;
        break;
        
        case CONFTYPE_BOOLEAN:	    /* all same as INT.. */
      case CONFTYPE_COMPRESS:
      case CONFTYPE_ENCRYPT:
      case CONFTYPE_ESTIMATE:
      case CONFTYPE_STRATEGY:
      case CONFTYPE_TAPERALGO:
      case CONFTYPE_PRIORITY:
      case CONFTYPE_HOLDING:
      case CONFTYPE_INT:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
        argvi++;
        break;
        
      case CONFTYPE_TIME:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
        argvi++;
        break;
        
      case CONFTYPE_REAL:
        ST(argvi) = sv_newmortal();
        sv_setnv(ST(argvi), val_t__real(result));
        argvi++;
        break;
        
        case CONFTYPE_IDENT:	    /* same as STRING */
      case CONFTYPE_STR:
        ST(argvi) = sv_newmortal();
        sv_setpv(ST(argvi), val_t__str(result));
        argvi++;
        break;
        
        /* No match yet -> not one of the "complex" types */
      default:
        SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
        break;
      }
    }
    
    XSRETURN(argvi);
  fail:
    
    SWIG_croak_null();
  }
}


XS(_wrap_getconf_seen) {
  {
    confparm_key arg1 ;
    gboolean result;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) {
      SWIG_croak("Usage: getconf_seen(key);");
    }
    {
      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));
      } else {
        g_critical("Unexpected signed int >64 bits?"); /* should be optimized out unless sizeof(signed int) > 8 */
      }
    }
    result = (gboolean)getconf_seen(arg1);
    {
      ST(argvi) = sv_2mortal(amglue_newSVi64(result));
      argvi++;
    }
    
    XSRETURN(argvi);
  fail:
    
    SWIG_croak_null();
  }
}


XS(_wrap_getconf_byname) {
  {
    char *arg1 = (char *) 0 ;
    val_t *result = 0 ;
    int res1 ;
    char *buf1 = 0 ;
    int alloc1 = 0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) {
      SWIG_croak("Usage: getconf_byname(key);");
    }
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getconf_byname" "', argument " "1"" of type '" "char *""'");
    }
    arg1 = (char *)(buf1);
    result = (val_t *)getconf_byname(arg1);
    {
      switch (result->type) {
        case CONFTYPE_RATE: {
          ST(argvi)= sv_newmortal();
          sv_setnv(ST(argvi), val_t__rate(result)[0]);
          argvi++;
          
          ST(argvi)= sv_newmortal();
          sv_setnv(ST(argvi), val_t__rate(result)[1]);
          argvi++;
          break;
        }
        
        case CONFTYPE_INTRANGE: {
          ST(argvi)= sv_newmortal();
          sv_setiv(ST(argvi), val_t__intrange(result)[0]);
          argvi++;
          
          ST(argvi)= sv_newmortal();
          sv_setiv(ST(argvi), val_t__intrange(result)[1]);
          argvi++;
          break;
          break;
        }
        
        case CONFTYPE_EXINCLUDE: {
          /* exincludes are represented in perl as {
          	     *	'list' : [ 'list1', 'list2', ..],
          	     *	'file' : [ 'file1', 'file2', ..],
          	     *	'optional' : 1,
          	     * }
          	     */
          exinclude_t *ei = &val_t__exinclude(result);
          AV *list_entries = (AV *)sv_2mortal((SV *)newAV());
          AV *file_entries = (AV *)sv_2mortal((SV *)newAV());
          SV *optional = sv_newmortal();
          HV *hv;
          sle_t *iter;
          
          /* first set up each of the hash values */
          
          if (ei->sl_list) {
            for (iter = ei->sl_list->first; iter != NULL; iter = iter->next) {
              av_push(list_entries, newSVpv(iter->name, 0));
            }
          }
          
          if(ei->sl_file) {
            for (iter = ei->sl_file->first; iter != NULL; iter = iter->next) {
              av_push(file_entries, newSVpv(iter->name, 0));
            }
          }
          
          sv_setiv(optional, ei->optional);
          
          /* now build the hash */
          hv = (HV *)sv_2mortal((SV *)newHV());
          
          hv_store(hv, "file", 4, newRV((SV *)file_entries), 0);
          hv_store(hv, "list", 4, newRV((SV *)list_entries), 0);
          hv_store(hv, "optional", 8, optional, 0);
          SvREFCNT_inc(optional);
          
          ST(argvi) = sv_2mortal(newRV((SV *)hv));
          argvi++;
          break;
        }
        
      case CONFTYPE_PROPLIST:
        ST(argvi) = sv_2mortal(g_hash_table_to_hashref(val_t__proplist(result)));
        argvi++;
        break;
        
      case CONFTYPE_SIZE:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__size(result)));
        argvi++;
        break;
        
      case CONFTYPE_AM64:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__am64(result)));
        argvi++;
        break;
        
        case CONFTYPE_BOOLEAN:	    /* all same as INT.. */
      case CONFTYPE_COMPRESS:
      case CONFTYPE_ENCRYPT:
      case CONFTYPE_ESTIMATE:
      case CONFTYPE_STRATEGY:
      case CONFTYPE_TAPERALGO:
      case CONFTYPE_PRIORITY:
      case CONFTYPE_HOLDING:
      case CONFTYPE_INT:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__int(result)));
        argvi++;
        break;
        
      case CONFTYPE_TIME:
        ST(argvi) = sv_2mortal(amglue_newSVi64(val_t__time(result)));
        argvi++;
        break;
        
      case CONFTYPE_REAL:
        ST(argvi) = sv_newmortal();
        sv_setnv(ST(argvi), val_t__real(result));
        argvi++;
        break;
        
        case CONFTYPE_IDENT:	    /* same as STRING */
      case CONFTYPE_STR:
        ST(argvi) = sv_newmortal();
        sv_setpv(ST(argvi), val_t__str(result));
        argvi++;
        break;
        
        /* No match yet -> not one of the "complex" types */
      default:
        SWIG_exception(SWIG_TypeError, "Unknown val_t conftype");
        break;
      }
    }
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    XSRETURN(argvi);
  fail:
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
    SWIG_croak_null();
  }
}


XS(_wrap_getconf_list) {
  {
    char *arg1 = (char *) 0 ;
    GSList *result = 0 ;
    int res1 ;
    char *buf1 = 0 ;
    int alloc1 = 0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) {
      SWIG_croak("Usage: getconf_list(listname);");
    }
    res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "getconf_list" "', argument " "1"" of type '" "char *""'");
    }
    arg1 = (char *)(buf1);
    result = (GSList *)getconf_list(arg1);
    {
      GSList *it = result;
      
      while (it) {
        ST(argvi) = sv_2mortal(newSVpv(it->data, 0));
        argvi++;
        it = it->next;
      }
      
      g_slist_free(result);
    }
    if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);