/* libguestfs generated file
 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
 *
 * Copyright (C) 2009 Red Hat Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "com_redhat_et_libguestfs_GuestFS.h"
#include "guestfs.h"

/* Note that this function returns.  The exception is not thrown
 * until after the wrapper function returns.
 */
static void
throw_exception (JNIEnv *env, const char *msg)
{
  jclass cl;
  cl = (*env)->FindClass (env,
                          "com/redhat/et/libguestfs/LibGuestFSException");
  (*env)->ThrowNew (env, cl, msg);
}

JNIEXPORT jlong JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1create
  (JNIEnv *env, jobject obj)
{
  guestfs_h *g;

  g = guestfs_create ();
  if (g == NULL) {
    throw_exception (env, "GuestFS.create: failed to allocate handle");
    return 0;
  }
  guestfs_set_error_handler (g, NULL, NULL);
  return (jlong) (long) g;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1close
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  guestfs_close (g);
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0
  (JNIEnv *env, jobject obj, jlong jg, jstring jstr, jstring joptstr, jobjectArray jstrlist, jboolean jb, jint jinteger, jstring jfilein, jstring jfileout)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *str;
  const char *optstr;
  int strlist_len;
  const char **strlist;
  int b;
  int integer;
  const char *filein;
  const char *fileout;
  int i;

  str = (*env)->GetStringUTFChars (env, jstr, NULL);
  optstr = joptstr ? (*env)->GetStringUTFChars (env, joptstr, NULL) : NULL;
  strlist_len = (*env)->GetArrayLength (env, jstrlist);
  strlist = guestfs_safe_malloc (g, sizeof (char *) * (strlist_len+1));
  for (i = 0; i < strlist_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
    strlist[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  strlist[strlist_len] = NULL;
  b = jb;
  integer = jinteger;
  filein = (*env)->GetStringUTFChars (env, jfilein, NULL);
  fileout = (*env)->GetStringUTFChars (env, jfileout, NULL);
  r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
  (*env)->ReleaseStringUTFChars (env, jstr, str);
  if (joptstr)
    (*env)->ReleaseStringUTFChars (env, joptstr, optstr);
  for (i = 0; i < strlist_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
    (*env)->ReleaseStringUTFChars (env, o, strlist[i]);
  }
  free (strlist);
  (*env)->ReleaseStringUTFChars (env, jfilein, filein);
  (*env)->ReleaseStringUTFChars (env, jfileout, fileout);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rint
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rint (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rinterr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_test0rinterr (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jlong JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rint64
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int64_t r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rint64 (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jlong) r;
}

JNIEXPORT jlong JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rint64err
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int64_t r;

  r = guestfs_test0rint64err (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jlong) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rbool
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rbool (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rboolerr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_test0rboolerr (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rconststring
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  const char *r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rconststring (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  return (*env)->NewStringUTF (env, r);
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rconststringerr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  const char *r;

  r = guestfs_test0rconststringerr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  return (*env)->NewStringUTF (env, r);
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstring
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rstring (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstringerr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;

  r = guestfs_test0rstringerr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlist
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *val;
  int i;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rstringlist (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlisterr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_test0rstringlisterr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rintbool
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_int_bool *r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rintbool (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "i", "I");
  (*env)->SetIntField (env, jr, fl, r->i);
  fl = (*env)->GetFieldID (env, cl, "i", "Z");
  (*env)->SetBooleanField (env, jr, fl, r->b);
  guestfs_free_int_bool (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rintboolerr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_int_bool *r;

  r = guestfs_test0rintboolerr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "i", "I");
  (*env)->SetIntField (env, jr, fl, r->i);
  fl = (*env)->GetFieldID (env, cl, "i", "Z");
  (*env)->SetBooleanField (env, jr, fl, r->b);
  guestfs_free_int_bool (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlist
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_pv_list *r;
  const char *val;
  int i;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rpvlist (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
    {
      char s[33];
      memcpy (s, r->val[i].pv_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_pv_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlisterr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_pv_list *r;
  int i;

  r = guestfs_test0rpvlisterr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
    {
      char s[33];
      memcpy (s, r->val[i].pv_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_pv_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rvglist
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_vg_list *r;
  const char *val;
  int i;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rvglist (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
    {
      char s[33];
      memcpy (s, r->val[i].vg_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_vg_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rvglisterr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_vg_list *r;
  int i;

  r = guestfs_test0rvglisterr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
    {
      char s[33];
      memcpy (s, r->val[i].vg_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_vg_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlist
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_lv_list *r;
  const char *val;
  int i;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rlvlist (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
    {
      char s[33];
      memcpy (s, r->val[i].lv_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_lv_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlisterr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_lv_list *r;
  int i;

  r = guestfs_test0rlvlisterr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
    {
      char s[33];
      memcpy (s, r->val[i].lv_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_lv_list (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstat
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_stat *r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rstat (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "dev", "J");
  (*env)->SetLongField (env, jr, fl, r->dev);
  fl = (*env)->GetFieldID (env, cl, "ino", "J");
  (*env)->SetLongField (env, jr, fl, r->ino);
  fl = (*env)->GetFieldID (env, cl, "mode", "J");
  (*env)->SetLongField (env, jr, fl, r->mode);
  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
  (*env)->SetLongField (env, jr, fl, r->nlink);
  fl = (*env)->GetFieldID (env, cl, "uid", "J");
  (*env)->SetLongField (env, jr, fl, r->uid);
  fl = (*env)->GetFieldID (env, cl, "gid", "J");
  (*env)->SetLongField (env, jr, fl, r->gid);
  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
  (*env)->SetLongField (env, jr, fl, r->rdev);
  fl = (*env)->GetFieldID (env, cl, "size", "J");
  (*env)->SetLongField (env, jr, fl, r->size);
  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
  (*env)->SetLongField (env, jr, fl, r->blksize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "atime", "J");
  (*env)->SetLongField (env, jr, fl, r->atime);
  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
  (*env)->SetLongField (env, jr, fl, r->mtime);
  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
  (*env)->SetLongField (env, jr, fl, r->ctime);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstaterr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_stat *r;

  r = guestfs_test0rstaterr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "dev", "J");
  (*env)->SetLongField (env, jr, fl, r->dev);
  fl = (*env)->GetFieldID (env, cl, "ino", "J");
  (*env)->SetLongField (env, jr, fl, r->ino);
  fl = (*env)->GetFieldID (env, cl, "mode", "J");
  (*env)->SetLongField (env, jr, fl, r->mode);
  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
  (*env)->SetLongField (env, jr, fl, r->nlink);
  fl = (*env)->GetFieldID (env, cl, "uid", "J");
  (*env)->SetLongField (env, jr, fl, r->uid);
  fl = (*env)->GetFieldID (env, cl, "gid", "J");
  (*env)->SetLongField (env, jr, fl, r->gid);
  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
  (*env)->SetLongField (env, jr, fl, r->rdev);
  fl = (*env)->GetFieldID (env, cl, "size", "J");
  (*env)->SetLongField (env, jr, fl, r->size);
  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
  (*env)->SetLongField (env, jr, fl, r->blksize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "atime", "J");
  (*env)->SetLongField (env, jr, fl, r->atime);
  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
  (*env)->SetLongField (env, jr, fl, r->mtime);
  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
  (*env)->SetLongField (env, jr, fl, r->ctime);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfs
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_statvfs *r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rstatvfs (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
  (*env)->SetLongField (env, jr, fl, r->bsize);
  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
  (*env)->SetLongField (env, jr, fl, r->frsize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
  (*env)->SetLongField (env, jr, fl, r->bfree);
  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
  (*env)->SetLongField (env, jr, fl, r->bavail);
  fl = (*env)->GetFieldID (env, cl, "files", "J");
  (*env)->SetLongField (env, jr, fl, r->files);
  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
  (*env)->SetLongField (env, jr, fl, r->ffree);
  fl = (*env)->GetFieldID (env, cl, "favail", "J");
  (*env)->SetLongField (env, jr, fl, r->favail);
  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
  (*env)->SetLongField (env, jr, fl, r->fsid);
  fl = (*env)->GetFieldID (env, cl, "flag", "J");
  (*env)->SetLongField (env, jr, fl, r->flag);
  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
  (*env)->SetLongField (env, jr, fl, r->namemax);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfserr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_statvfs *r;

  r = guestfs_test0rstatvfserr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
  (*env)->SetLongField (env, jr, fl, r->bsize);
  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
  (*env)->SetLongField (env, jr, fl, r->frsize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
  (*env)->SetLongField (env, jr, fl, r->bfree);
  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
  (*env)->SetLongField (env, jr, fl, r->bavail);
  fl = (*env)->GetFieldID (env, cl, "files", "J");
  (*env)->SetLongField (env, jr, fl, r->files);
  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
  (*env)->SetLongField (env, jr, fl, r->ffree);
  fl = (*env)->GetFieldID (env, cl, "favail", "J");
  (*env)->SetLongField (env, jr, fl, r->favail);
  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
  (*env)->SetLongField (env, jr, fl, r->fsid);
  fl = (*env)->GetFieldID (env, cl, "flag", "J");
  (*env)->SetLongField (env, jr, fl, r->flag);
  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
  (*env)->SetLongField (env, jr, fl, r->namemax);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtable
  (JNIEnv *env, jobject obj, jlong jg, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  char **r;
  const char *val;

  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_test0rhashtable (g, val);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  throw_exception (env, "test0rhashtable: internal error: please let us know how to make a Java HashMap from JNI bindings!");
  return NULL;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtableerr
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  char **r;

  r = guestfs_test0rhashtableerr (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  throw_exception (env, "test0rhashtableerr: internal error: please let us know how to make a Java HashMap from JNI bindings!");
  return NULL;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1launch
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_launch (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_wait_ready (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_kill_subprocess (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *filename;

  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
  r = guestfs_add_drive (g, filename);
  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *filename;

  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
  r = guestfs_add_cdrom (g, filename);
  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1add_1drive_1ro
  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *filename;

  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
  r = guestfs_add_drive_ro (g, filename);
  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1config
  (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *qemuparam;
  const char *qemuvalue;

  qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
  qemuvalue = jqemuvalue ? (*env)->GetStringUTFChars (env, jqemuvalue, NULL) : NULL;
  r = guestfs_config (g, qemuparam, qemuvalue);
  (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
  if (jqemuvalue)
    (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
  (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *qemu;

  qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
  r = guestfs_set_qemu (g, qemu);
  (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  const char *r;

  r = guestfs_get_qemu (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  return (*env)->NewStringUTF (env, r);
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1path
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_set_path (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1path
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  const char *r;

  r = guestfs_get_path (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  return (*env)->NewStringUTF (env, r);
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1append
  (JNIEnv *env, jobject obj, jlong jg, jstring jappend)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *append;

  append = (*env)->GetStringUTFChars (env, jappend, NULL);
  r = guestfs_set_append (g, append);
  (*env)->ReleaseStringUTFChars (env, jappend, append);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1append
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  const char *r;

  r = guestfs_get_append (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  return (*env)->NewStringUTF (env, r);
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
  (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int autosync;

  autosync = jautosync;
  r = guestfs_set_autosync (g, autosync);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_get_autosync (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
  (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int verbose;

  verbose = jverbose;
  r = guestfs_set_verbose (g, verbose);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_get_verbose (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_is_ready (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1is_1config
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_is_config (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_is_launching (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_is_busy (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1state
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_get_state (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_set_busy (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_set_ready (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1end_1busy
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_end_busy (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mount
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  const char *mountpoint;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
  r = guestfs_mount (g, device, mountpoint);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sync
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_sync (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1touch
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_touch (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1cat
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_cat (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1ll
  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *directory;

  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  r = guestfs_ll (g, directory);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1ls
  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *directory;
  int i;

  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  r = guestfs_ls (g, directory);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_list_devices (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_list_partitions (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1pvs
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_pvs (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1vgs
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_vgs (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lvs
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_lvs (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_pv_list *r;
  int i;

  r = guestfs_pvs_full (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
    {
      char s[33];
      memcpy (s, r->val[i].pv_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
    fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
    fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
    fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
    fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
    fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
    fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
    fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
    fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
    fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
    fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
    fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_pv_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_vg_list *r;
  int i;

  r = guestfs_vgs_full (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
    {
      char s[33];
      memcpy (s, r->val[i].vg_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
    fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
    fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
    fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
    fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
    fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
    fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
    fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
    fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
    fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
    fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
    fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
    fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
    fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
    fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
    fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
    fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_vg_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  jclass cl;
  jfieldID fl;
  jobject jfl;
  struct guestfs_lvm_lv_list *r;
  int i;

  r = guestfs_lvs_full (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
  jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
  for (i = 0; i < r->len; ++i) {
    jfl = (*env)->AllocObject (env, cl);
    fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
    {
      char s[33];
      memcpy (s, r->val[i].lv_uuid, 32);
      s[32] = 0;
      fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
      (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
    }
    fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
    fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
    fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
    fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
    fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
    fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
    fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
    (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
    fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
    fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
    (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
    fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
    (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
    fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
    fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
    fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
    fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
    (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
    (*env)->SetObjectArrayElement (env, jfl, i, jfl);
  }
  guestfs_free_lvm_lv_list (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *path;
  int i;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_read_lines (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
  (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *root;
  int flags;

  root = (*env)->GetStringUTFChars (env, jroot, NULL);
  flags = jflags;
  r = guestfs_aug_init (g, root, flags);
  (*env)->ReleaseStringUTFChars (env, jroot, root);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_aug_close (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
  (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *name;
  const char *expr;

  name = (*env)->GetStringUTFChars (env, jname, NULL);
  expr = jexpr ? (*env)->GetStringUTFChars (env, jexpr, NULL) : NULL;
  r = guestfs_aug_defvar (g, name, expr);
  (*env)->ReleaseStringUTFChars (env, jname, name);
  if (jexpr)
    (*env)->ReleaseStringUTFChars (env, jexpr, expr);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
  (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_int_bool *r;
  const char *name;
  const char *expr;
  const char *val;

  name = (*env)->GetStringUTFChars (env, jname, NULL);
  expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_aug_defnode (g, name, expr, val);
  (*env)->ReleaseStringUTFChars (env, jname, name);
  (*env)->ReleaseStringUTFChars (env, jexpr, expr);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "i", "I");
  (*env)->SetIntField (env, jr, fl, r->i);
  fl = (*env)->GetFieldID (env, cl, "i", "Z");
  (*env)->SetBooleanField (env, jr, fl, r->b);
  guestfs_free_int_bool (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_aug_get (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;
  const char *val;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  val = (*env)->GetStringUTFChars (env, jval, NULL);
  r = guestfs_aug_set (g, path, val);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  (*env)->ReleaseStringUTFChars (env, jval, val);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;
  const char *label;
  int before;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  label = (*env)->GetStringUTFChars (env, jlabel, NULL);
  before = jbefore;
  r = guestfs_aug_insert (g, path, label, before);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  (*env)->ReleaseStringUTFChars (env, jlabel, label);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_aug_rm (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *src;
  const char *dest;

  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
  r = guestfs_aug_mv (g, src, dest);
  (*env)->ReleaseStringUTFChars (env, jsrc, src);
  (*env)->ReleaseStringUTFChars (env, jdest, dest);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *path;
  int i;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_aug_match (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_aug_save (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_aug_load (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *path;
  int i;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_aug_ls (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1rm
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_rm (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1rmdir
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_rmdir (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_rm_rf (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mkdir
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_mkdir (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_mkdir_p (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1chmod
  (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int mode;
  const char *path;

  mode = jmode;
  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_chmod (g, mode, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1chown
  (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int owner;
  int group;
  const char *path;

  owner = jowner;
  group = jgroup;
  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_chown (g, owner, group, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1exists
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_exists (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1is_1file
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_is_file (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_is_dir (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_pvcreate (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
  (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *volgroup;
  int physvols_len;
  const char **physvols;
  int i;

  volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
  physvols_len = (*env)->GetArrayLength (env, jphysvols);
  physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
  for (i = 0; i < physvols_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
    physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  physvols[physvols_len] = NULL;
  r = guestfs_vgcreate (g, volgroup, physvols);
  (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
  for (i = 0; i < physvols_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
    (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
  }
  free (physvols);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
  (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *logvol;
  const char *volgroup;
  int mbytes;

  logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
  volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
  mbytes = jmbytes;
  r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
  (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
  (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mkfs
  (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *fstype;
  const char *device;

  fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_mkfs (g, fstype, device);
  (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  int cyls;
  int heads;
  int sectors;
  int lines_len;
  const char **lines;
  int i;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  cyls = jcyls;
  heads = jheads;
  sectors = jsectors;
  lines_len = (*env)->GetArrayLength (env, jlines);
  lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
  for (i = 0; i < lines_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
    lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  lines[lines_len] = NULL;
  r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  for (i = 0; i < lines_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
    (*env)->ReleaseStringUTFChars (env, o, lines[i]);
  }
  free (lines);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1write_1file
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;
  const char *content;
  int size;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  content = (*env)->GetStringUTFChars (env, jcontent, NULL);
  size = jsize;
  r = guestfs_write_file (g, path, content, size);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  (*env)->ReleaseStringUTFChars (env, jcontent, content);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1umount
  (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *pathordevice;

  pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
  r = guestfs_umount (g, pathordevice);
  (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mounts
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int i;

  r = guestfs_mounts (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_umount_all (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_lvm_remove_all (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1file
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_file (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1command
  (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  int arguments_len;
  const char **arguments;
  int i;

  arguments_len = (*env)->GetArrayLength (env, jarguments);
  arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
  for (i = 0; i < arguments_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
    arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  arguments[arguments_len] = NULL;
  r = guestfs_command (g, arguments);
  for (i = 0; i < arguments_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
    (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
  }
  free (arguments);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
  (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int arguments_len;
  const char **arguments;
  int i;

  arguments_len = (*env)->GetArrayLength (env, jarguments);
  arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
  for (i = 0; i < arguments_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
    arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  arguments[arguments_len] = NULL;
  r = guestfs_command_lines (g, arguments);
  for (i = 0; i < arguments_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
    (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
  }
  free (arguments);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1stat
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_stat *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_stat (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "dev", "J");
  (*env)->SetLongField (env, jr, fl, r->dev);
  fl = (*env)->GetFieldID (env, cl, "ino", "J");
  (*env)->SetLongField (env, jr, fl, r->ino);
  fl = (*env)->GetFieldID (env, cl, "mode", "J");
  (*env)->SetLongField (env, jr, fl, r->mode);
  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
  (*env)->SetLongField (env, jr, fl, r->nlink);
  fl = (*env)->GetFieldID (env, cl, "uid", "J");
  (*env)->SetLongField (env, jr, fl, r->uid);
  fl = (*env)->GetFieldID (env, cl, "gid", "J");
  (*env)->SetLongField (env, jr, fl, r->gid);
  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
  (*env)->SetLongField (env, jr, fl, r->rdev);
  fl = (*env)->GetFieldID (env, cl, "size", "J");
  (*env)->SetLongField (env, jr, fl, r->size);
  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
  (*env)->SetLongField (env, jr, fl, r->blksize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "atime", "J");
  (*env)->SetLongField (env, jr, fl, r->atime);
  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
  (*env)->SetLongField (env, jr, fl, r->mtime);
  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
  (*env)->SetLongField (env, jr, fl, r->ctime);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lstat
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_stat *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_lstat (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "dev", "J");
  (*env)->SetLongField (env, jr, fl, r->dev);
  fl = (*env)->GetFieldID (env, cl, "ino", "J");
  (*env)->SetLongField (env, jr, fl, r->ino);
  fl = (*env)->GetFieldID (env, cl, "mode", "J");
  (*env)->SetLongField (env, jr, fl, r->mode);
  fl = (*env)->GetFieldID (env, cl, "nlink", "J");
  (*env)->SetLongField (env, jr, fl, r->nlink);
  fl = (*env)->GetFieldID (env, cl, "uid", "J");
  (*env)->SetLongField (env, jr, fl, r->uid);
  fl = (*env)->GetFieldID (env, cl, "gid", "J");
  (*env)->SetLongField (env, jr, fl, r->gid);
  fl = (*env)->GetFieldID (env, cl, "rdev", "J");
  (*env)->SetLongField (env, jr, fl, r->rdev);
  fl = (*env)->GetFieldID (env, cl, "size", "J");
  (*env)->SetLongField (env, jr, fl, r->size);
  fl = (*env)->GetFieldID (env, cl, "blksize", "J");
  (*env)->SetLongField (env, jr, fl, r->blksize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "atime", "J");
  (*env)->SetLongField (env, jr, fl, r->atime);
  fl = (*env)->GetFieldID (env, cl, "mtime", "J");
  (*env)->SetLongField (env, jr, fl, r->mtime);
  fl = (*env)->GetFieldID (env, cl, "ctime", "J");
  (*env)->SetLongField (env, jr, fl, r->ctime);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1statvfs
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobject jr;
  jclass cl;
  jfieldID fl;
  struct guestfs_statvfs *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_statvfs (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
  jr = (*env)->AllocObject (env, cl);
  fl = (*env)->GetFieldID (env, cl, "bsize", "J");
  (*env)->SetLongField (env, jr, fl, r->bsize);
  fl = (*env)->GetFieldID (env, cl, "frsize", "J");
  (*env)->SetLongField (env, jr, fl, r->frsize);
  fl = (*env)->GetFieldID (env, cl, "blocks", "J");
  (*env)->SetLongField (env, jr, fl, r->blocks);
  fl = (*env)->GetFieldID (env, cl, "bfree", "J");
  (*env)->SetLongField (env, jr, fl, r->bfree);
  fl = (*env)->GetFieldID (env, cl, "bavail", "J");
  (*env)->SetLongField (env, jr, fl, r->bavail);
  fl = (*env)->GetFieldID (env, cl, "files", "J");
  (*env)->SetLongField (env, jr, fl, r->files);
  fl = (*env)->GetFieldID (env, cl, "ffree", "J");
  (*env)->SetLongField (env, jr, fl, r->ffree);
  fl = (*env)->GetFieldID (env, cl, "favail", "J");
  (*env)->SetLongField (env, jr, fl, r->favail);
  fl = (*env)->GetFieldID (env, cl, "fsid", "J");
  (*env)->SetLongField (env, jr, fl, r->fsid);
  fl = (*env)->GetFieldID (env, cl, "flag", "J");
  (*env)->SetLongField (env, jr, fl, r->flag);
  fl = (*env)->GetFieldID (env, cl, "namemax", "J");
  (*env)->SetLongField (env, jr, fl, r->namemax);
  free (r);
  return jr;
}

JNIEXPORT jobject JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  char **r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_tune2fs_l (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
  return NULL;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_setro (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_setrw (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_getro (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_getss (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_getbsz (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  int blocksize;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  blocksize = jblocksize;
  r = guestfs_blockdev_setbsz (g, device, blocksize);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jlong JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int64_t r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_getsz (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jlong) r;
}

JNIEXPORT jlong JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int64_t r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_getsize64 (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jlong) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_flushbufs (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_blockdev_rereadpt (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1upload
  (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *filename;
  const char *remotefilename;

  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
  remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
  r = guestfs_upload (g, filename, remotefilename);
  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
  (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1download
  (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *remotefilename;
  const char *filename;

  remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
  filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
  r = guestfs_download (g, remotefilename, filename);
  (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
  (*env)->ReleaseStringUTFChars (env, jfilename, filename);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1checksum
  (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *csumtype;
  const char *path;

  csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_checksum (g, csumtype, path);
  (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
  (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *tarfile;
  const char *directory;

  tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  r = guestfs_tar_in (g, tarfile, directory);
  (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *directory;
  const char *tarfile;

  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
  r = guestfs_tar_out (g, directory, tarfile);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
  (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *tarball;
  const char *directory;

  tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  r = guestfs_tgz_in (g, tarball, directory);
  (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *directory;
  const char *tarball;

  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
  r = guestfs_tgz_out (g, directory, tarball);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  const char *mountpoint;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
  r = guestfs_mount_ro (g, device, mountpoint);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
  (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *options;
  const char *device;
  const char *mountpoint;

  options = (*env)->GetStringUTFChars (env, joptions, NULL);
  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
  r = guestfs_mount_options (g, options, device, mountpoint);
  (*env)->ReleaseStringUTFChars (env, joptions, options);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
  (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *options;
  const char *vfstype;
  const char *device;
  const char *mountpoint;

  options = (*env)->GetStringUTFChars (env, joptions, NULL);
  vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
  r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
  (*env)->ReleaseStringUTFChars (env, joptions, options);
  (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1debug
  (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *subcmd;
  int extraargs_len;
  const char **extraargs;
  int i;

  subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
  extraargs_len = (*env)->GetArrayLength (env, jextraargs);
  extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
  for (i = 0; i < extraargs_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
    extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  extraargs[extraargs_len] = NULL;
  r = guestfs_debug (g, subcmd, extraargs);
  (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
  for (i = 0; i < extraargs_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
    (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
  }
  free (extraargs);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lvremove
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_lvremove (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1vgremove
  (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *vgname;

  vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
  r = guestfs_vgremove (g, vgname);
  (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1pvremove
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_pvremove (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  const char *label;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  label = (*env)->GetStringUTFChars (env, jlabel, NULL);
  r = guestfs_set_e2label (g, device, label);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, jlabel, label);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_get_e2label (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  const char *uuid;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
  r = guestfs_set_e2uuid (g, device, uuid);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, juuid, uuid);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_get_e2uuid (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1fsck
  (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *fstype;
  const char *device;

  fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_fsck (g, fstype, device);
  (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1zero
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_zero (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
  (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *root;
  const char *device;

  root = (*env)->GetStringUTFChars (env, jroot, NULL);
  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_grub_install (g, root, device);
  (*env)->ReleaseStringUTFChars (env, jroot, root);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1cp
  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *src;
  const char *dest;

  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
  r = guestfs_cp (g, src, dest);
  (*env)->ReleaseStringUTFChars (env, jsrc, src);
  (*env)->ReleaseStringUTFChars (env, jdest, dest);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *src;
  const char *dest;

  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
  r = guestfs_cp_a (g, src, dest);
  (*env)->ReleaseStringUTFChars (env, jsrc, src);
  (*env)->ReleaseStringUTFChars (env, jdest, dest);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mv
  (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *src;
  const char *dest;

  src = (*env)->GetStringUTFChars (env, jsrc, NULL);
  dest = (*env)->GetStringUTFChars (env, jdest, NULL);
  r = guestfs_mv (g, src, dest);
  (*env)->ReleaseStringUTFChars (env, jsrc, src);
  (*env)->ReleaseStringUTFChars (env, jdest, dest);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
  (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int whattodrop;

  whattodrop = jwhattodrop;
  r = guestfs_drop_caches (g, whattodrop);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1dmesg
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;

  r = guestfs_dmesg (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;

  r = guestfs_ping_daemon (g);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jboolean JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1equal
  (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *file1;
  const char *file2;

  file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
  file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
  r = guestfs_equal (g, file1, file2);
  (*env)->ReleaseStringUTFChars (env, jfile1, file1);
  (*env)->ReleaseStringUTFChars (env, jfile2, file2);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jboolean) r;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1strings
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *path;
  int i;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_strings (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
  (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *encoding;
  const char *path;
  int i;

  encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_strings_e (g, encoding, path);
  (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1hexdump
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_hexdump (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1zerofree
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_zerofree (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1pvresize
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_pvresize (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1N
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jpartnum, jint jcyls, jint jheads, jint jsectors, jstring jline)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  int partnum;
  int cyls;
  int heads;
  int sectors;
  const char *line;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  partnum = jpartnum;
  cyls = jcyls;
  heads = jheads;
  sectors = jsectors;
  line = (*env)->GetStringUTFChars (env, jline, NULL);
  r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  (*env)->ReleaseStringUTFChars (env, jline, line);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1l
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_sfdisk_l (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1kernel_1geometry
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_sfdisk_kernel_geometry (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1disk_1geometry
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_sfdisk_disk_geometry (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate_1all
  (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int activate;

  activate = jactivate;
  r = guestfs_vg_activate_all (g, activate);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate
  (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate, jobjectArray jvolgroups)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int activate;
  int volgroups_len;
  const char **volgroups;
  int i;

  activate = jactivate;
  volgroups_len = (*env)->GetArrayLength (env, jvolgroups);
  volgroups = guestfs_safe_malloc (g, sizeof (char *) * (volgroups_len+1));
  for (i = 0; i < volgroups_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
    volgroups[i] = (*env)->GetStringUTFChars (env, o, NULL);
  }
  volgroups[volgroups_len] = NULL;
  r = guestfs_vg_activate (g, activate, volgroups);
  for (i = 0; i < volgroups_len; ++i) {
    jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
    (*env)->ReleaseStringUTFChars (env, o, volgroups[i]);
  }
  free (volgroups);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1lvresize
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jmbytes)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;
  int mbytes;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  mbytes = jmbytes;
  r = guestfs_lvresize (g, device, mbytes);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1resize2fs
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_resize2fs (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1find
  (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *directory;
  int i;

  directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
  r = guestfs_find (g, directory);
  (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1e2fsck_1f
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_e2fsck_f (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sleep
  (JNIEnv *env, jobject obj, jlong jg, jint jsecs)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int secs;

  secs = jsecs;
  r = guestfs_sleep (g, secs);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1ntfs_13g_1probe
  (JNIEnv *env, jobject obj, jlong jg, jboolean jrw, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  int rw;
  const char *device;

  rw = jrw;
  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_ntfs_3g_probe (g, rw, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sh
  (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *command;

  command = (*env)->GetStringUTFChars (env, jcommand, NULL);
  r = guestfs_sh (g, command);
  (*env)->ReleaseStringUTFChars (env, jcommand, command);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1sh_1lines
  (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *command;
  int i;

  command = (*env)->GetStringUTFChars (env, jcommand, NULL);
  r = guestfs_sh_lines (g, command);
  (*env)->ReleaseStringUTFChars (env, jcommand, command);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1glob_1expand
  (JNIEnv *env, jobject obj, jlong jg, jstring jpattern)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *pattern;
  int i;

  pattern = (*env)->GetStringUTFChars (env, jpattern, NULL);
  r = guestfs_glob_expand (g, pattern);
  (*env)->ReleaseStringUTFChars (env, jpattern, pattern);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1scrub_1device
  (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *device;

  device = (*env)->GetStringUTFChars (env, jdevice, NULL);
  r = guestfs_scrub_device (g, device);
  (*env)->ReleaseStringUTFChars (env, jdevice, device);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1scrub_1file
  (JNIEnv *env, jobject obj, jlong jg, jstring jfile)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *file;

  file = (*env)->GetStringUTFChars (env, jfile, NULL);
  r = guestfs_scrub_file (g, file);
  (*env)->ReleaseStringUTFChars (env, jfile, file);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT void JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1scrub_1freespace
  (JNIEnv *env, jobject obj, jlong jg, jstring jdir)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *dir;

  dir = (*env)->GetStringUTFChars (env, jdir, NULL);
  r = guestfs_scrub_freespace (g, dir);
  (*env)->ReleaseStringUTFChars (env, jdir, dir);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return ;
  }
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1mkdtemp
  (JNIEnv *env, jobject obj, jlong jg, jstring jtemplate)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;
  const char *template;

  template = (*env)->GetStringUTFChars (env, jtemplate, NULL);
  r = guestfs_mkdtemp (g, template);
  (*env)->ReleaseStringUTFChars (env, jtemplate, template);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1wc_1l
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_wc_l (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1wc_1w
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_wc_w (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jint JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1wc_1c
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_wc_c (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jint) r;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1head
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *path;
  int i;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_head (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1head_1n
  (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int nrlines;
  const char *path;
  int i;

  nrlines = jnrlines;
  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_head_n (g, nrlines, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tail
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  const char *path;
  int i;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_tail (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jobjectArray JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1tail_1n
  (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jobjectArray jr;
  int r_len;
  jclass cl;
  jstring jstr;
  char **r;
  int nrlines;
  const char *path;
  int i;

  nrlines = jnrlines;
  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_tail_n (g, nrlines, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  for (r_len = 0; r[r_len] != NULL; ++r_len) ;
  cl = (*env)->FindClass (env, "java/lang/String");
  jstr = (*env)->NewStringUTF (env, "");
  jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
  for (i = 0; i < r_len; ++i) {
    jstr = (*env)->NewStringUTF (env, r[i]);
    (*env)->SetObjectArrayElement (env, jr, i, jstr);
    free (r[i]);
  }
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1df
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;

  r = guestfs_df (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jstring JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1df_1h
  (JNIEnv *env, jobject obj, jlong jg)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  jstring jr;
  char *r;

  r = guestfs_df_h (g);
  if (r == NULL) {
    throw_exception (env, guestfs_last_error (g));
    return NULL;
  }
  jr = (*env)->NewStringUTF (env, r);
  free (r);
  return jr;
}

JNIEXPORT jlong JNICALL
Java_com_redhat_et_libguestfs_GuestFS__1du
  (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
{
  guestfs_h *g = (guestfs_h *) (long) jg;
  int64_t r;
  const char *path;

  path = (*env)->GetStringUTFChars (env, jpath, NULL);
  r = guestfs_du (g, path);
  (*env)->ReleaseStringUTFChars (env, jpath, path);
  if (r == -1) {
    throw_exception (env, guestfs_last_error (g));
    return 0;
  }
  return (jlong) r;
}