java/com_redhat_et_libguestfs_GuestFS.c

   1 /* libguestfs generated file
   2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
   3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
   4  *
   5  * Copyright (C) 2009 Red Hat Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25
  26 #include "com_redhat_et_libguestfs_GuestFS.h"
  27 #include "guestfs.h"
  28
  29 /* Note that this function returns.  The exception is not thrown
  30  * until after the wrapper function returns.
  31  */
  32 static void
  33 throw_exception (JNIEnv *env, const char *msg)
  34 {
  35   jclass cl;
  36   cl = (*env)->FindClass (env,
  37                           "com/redhat/et/libguestfs/LibGuestFSException");
  38   (*env)->ThrowNew (env, cl, msg);
  39 }
  40
  41 JNIEXPORT jlong JNICALL
  42 Java_com_redhat_et_libguestfs_GuestFS__1create
  43   (JNIEnv *env, jobject obj)
  44 {
  45   guestfs_h *g;
  46
  47   g = guestfs_create ();
  48   if (g == NULL) {
  49     throw_exception (env, "GuestFS.create: failed to allocate handle");
  50     return 0;
  51   }
  52   guestfs_set_error_handler (g, NULL, NULL);
  53   return (jlong) (long) g;
  54 }
  55
  56 JNIEXPORT void JNICALL
  57 Java_com_redhat_et_libguestfs_GuestFS__1close
  58   (JNIEnv *env, jobject obj, jlong jg)
  59 {
  60   guestfs_h *g = (guestfs_h *) (long) jg;
  61   guestfs_close (g);
  62 }
  63
  64 JNIEXPORT void JNICALL
  65 Java_com_redhat_et_libguestfs_GuestFS__1test0
  66   (JNIEnv *env, jobject obj, jlong jg, jstring jstr, jstring joptstr, jobjectArray jstrlist, jboolean jb, jint jinteger, jstring jfilein, jstring jfileout)
  67 {
  68   guestfs_h *g = (guestfs_h *) (long) jg;
  69   int r;
  70   const char *str;
  71   const char *optstr;
  72   int strlist_len;
  73   const char **strlist;
  74   int b;
  75   int integer;
  76   const char *filein;
  77   const char *fileout;
  78   int i;
  79
  80   str = (*env)->GetStringUTFChars (env, jstr, NULL);
  81   optstr = (*env)->GetStringUTFChars (env, joptstr, NULL);
  82   strlist_len = (*env)->GetArrayLength (env, jstrlist);
  83   strlist = guestfs_safe_malloc (g, sizeof (char *) * (strlist_len+1));
  84   for (i = 0; i < strlist_len; ++i) {
  85     jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
  86     strlist[i] = (*env)->GetStringUTFChars (env, o, NULL);
  87   }
  88   strlist[strlist_len] = NULL;
  89   b = jb;
  90   integer = jinteger;
  91   filein = (*env)->GetStringUTFChars (env, jfilein, NULL);
  92   fileout = (*env)->GetStringUTFChars (env, jfileout, NULL);
  93   r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
  94   (*env)->ReleaseStringUTFChars (env, jstr, str);
  95   (*env)->ReleaseStringUTFChars (env, joptstr, optstr);
  96   for (i = 0; i < strlist_len; ++i) {
  97     jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
  98     (*env)->ReleaseStringUTFChars (env, o, strlist[i]);
  99   }
 100   free (strlist);
 101   (*env)->ReleaseStringUTFChars (env, jfilein, filein);
 102   (*env)->ReleaseStringUTFChars (env, jfileout, fileout);
 103   if (r == -1) {
 104     throw_exception (env, guestfs_last_error (g));
 105     return ;
 106   }
 107 }
 108
 109 JNIEXPORT jint JNICALL
 110 Java_com_redhat_et_libguestfs_GuestFS__1test0rint
 111   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 112 {
 113   guestfs_h *g = (guestfs_h *) (long) jg;
 114   int r;
 115   const char *val;
 116
 117   val = (*env)->GetStringUTFChars (env, jval, NULL);
 118   r = guestfs_test0rint (g, val);
 119   (*env)->ReleaseStringUTFChars (env, jval, val);
 120   if (r == -1) {
 121     throw_exception (env, guestfs_last_error (g));
 122     return 0;
 123   }
 124   return (jint) r;
 125 }
 126
 127 JNIEXPORT jint JNICALL
 128 Java_com_redhat_et_libguestfs_GuestFS__1test0rinterr
 129   (JNIEnv *env, jobject obj, jlong jg)
 130 {
 131   guestfs_h *g = (guestfs_h *) (long) jg;
 132   int r;
 133
 134   r = guestfs_test0rinterr (g);
 135   if (r == -1) {
 136     throw_exception (env, guestfs_last_error (g));
 137     return 0;
 138   }
 139   return (jint) r;
 140 }
 141
 142 JNIEXPORT jlong JNICALL
 143 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64
 144   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 145 {
 146   guestfs_h *g = (guestfs_h *) (long) jg;
 147   int64_t r;
 148   const char *val;
 149
 150   val = (*env)->GetStringUTFChars (env, jval, NULL);
 151   r = guestfs_test0rint64 (g, val);
 152   (*env)->ReleaseStringUTFChars (env, jval, val);
 153   if (r == -1) {
 154     throw_exception (env, guestfs_last_error (g));
 155     return 0;
 156   }
 157   return (jlong) r;
 158 }
 159
 160 JNIEXPORT jlong JNICALL
 161 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64err
 162   (JNIEnv *env, jobject obj, jlong jg)
 163 {
 164   guestfs_h *g = (guestfs_h *) (long) jg;
 165   int64_t r;
 166
 167   r = guestfs_test0rint64err (g);
 168   if (r == -1) {
 169     throw_exception (env, guestfs_last_error (g));
 170     return 0;
 171   }
 172   return (jlong) r;
 173 }
 174
 175 JNIEXPORT jboolean JNICALL
 176 Java_com_redhat_et_libguestfs_GuestFS__1test0rbool
 177   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 178 {
 179   guestfs_h *g = (guestfs_h *) (long) jg;
 180   int r;
 181   const char *val;
 182
 183   val = (*env)->GetStringUTFChars (env, jval, NULL);
 184   r = guestfs_test0rbool (g, val);
 185   (*env)->ReleaseStringUTFChars (env, jval, val);
 186   if (r == -1) {
 187     throw_exception (env, guestfs_last_error (g));
 188     return 0;
 189   }
 190   return (jboolean) r;
 191 }
 192
 193 JNIEXPORT jboolean JNICALL
 194 Java_com_redhat_et_libguestfs_GuestFS__1test0rboolerr
 195   (JNIEnv *env, jobject obj, jlong jg)
 196 {
 197   guestfs_h *g = (guestfs_h *) (long) jg;
 198   int r;
 199
 200   r = guestfs_test0rboolerr (g);
 201   if (r == -1) {
 202     throw_exception (env, guestfs_last_error (g));
 203     return 0;
 204   }
 205   return (jboolean) r;
 206 }
 207
 208 JNIEXPORT jstring JNICALL
 209 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststring
 210   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 211 {
 212   guestfs_h *g = (guestfs_h *) (long) jg;
 213   const char *r;
 214   const char *val;
 215
 216   val = (*env)->GetStringUTFChars (env, jval, NULL);
 217   r = guestfs_test0rconststring (g, val);
 218   (*env)->ReleaseStringUTFChars (env, jval, val);
 219   if (r == NULL) {
 220     throw_exception (env, guestfs_last_error (g));
 221     return NULL;
 222   }
 223   return (*env)->NewStringUTF (env, r);
 224 }
 225
 226 JNIEXPORT jstring JNICALL
 227 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststringerr
 228   (JNIEnv *env, jobject obj, jlong jg)
 229 {
 230   guestfs_h *g = (guestfs_h *) (long) jg;
 231   const char *r;
 232
 233   r = guestfs_test0rconststringerr (g);
 234   if (r == NULL) {
 235     throw_exception (env, guestfs_last_error (g));
 236     return NULL;
 237   }
 238   return (*env)->NewStringUTF (env, r);
 239 }
 240
 241 JNIEXPORT jstring JNICALL
 242 Java_com_redhat_et_libguestfs_GuestFS__1test0rstring
 243   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 244 {
 245   guestfs_h *g = (guestfs_h *) (long) jg;
 246   jstring jr;
 247   char *r;
 248   const char *val;
 249
 250   val = (*env)->GetStringUTFChars (env, jval, NULL);
 251   r = guestfs_test0rstring (g, val);
 252   (*env)->ReleaseStringUTFChars (env, jval, val);
 253   if (r == NULL) {
 254     throw_exception (env, guestfs_last_error (g));
 255     return NULL;
 256   }
 257   jr = (*env)->NewStringUTF (env, r);
 258   free (r);
 259   return jr;
 260 }
 261
 262 JNIEXPORT jstring JNICALL
 263 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringerr
 264   (JNIEnv *env, jobject obj, jlong jg)
 265 {
 266   guestfs_h *g = (guestfs_h *) (long) jg;
 267   jstring jr;
 268   char *r;
 269
 270   r = guestfs_test0rstringerr (g);
 271   if (r == NULL) {
 272     throw_exception (env, guestfs_last_error (g));
 273     return NULL;
 274   }
 275   jr = (*env)->NewStringUTF (env, r);
 276   free (r);
 277   return jr;
 278 }
 279
 280 JNIEXPORT jobjectArray JNICALL
 281 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlist
 282   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 283 {
 284   guestfs_h *g = (guestfs_h *) (long) jg;
 285   jobjectArray jr;
 286   int r_len;
 287   jclass cl;
 288   jstring jstr;
 289   char **r;
 290   const char *val;
 291   int i;
 292
 293   val = (*env)->GetStringUTFChars (env, jval, NULL);
 294   r = guestfs_test0rstringlist (g, val);
 295   (*env)->ReleaseStringUTFChars (env, jval, val);
 296   if (r == NULL) {
 297     throw_exception (env, guestfs_last_error (g));
 298     return NULL;
 299   }
 300   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 301   cl = (*env)->FindClass (env, "java/lang/String");
 302   jstr = (*env)->NewStringUTF (env, "");
 303   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 304   for (i = 0; i < r_len; ++i) {
 305     jstr = (*env)->NewStringUTF (env, r[i]);
 306     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 307     free (r[i]);
 308   }
 309   free (r);
 310   return jr;
 311 }
 312
 313 JNIEXPORT jobjectArray JNICALL
 314 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlisterr
 315   (JNIEnv *env, jobject obj, jlong jg)
 316 {
 317   guestfs_h *g = (guestfs_h *) (long) jg;
 318   jobjectArray jr;
 319   int r_len;
 320   jclass cl;
 321   jstring jstr;
 322   char **r;
 323   int i;
 324
 325   r = guestfs_test0rstringlisterr (g);
 326   if (r == NULL) {
 327     throw_exception (env, guestfs_last_error (g));
 328     return NULL;
 329   }
 330   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 331   cl = (*env)->FindClass (env, "java/lang/String");
 332   jstr = (*env)->NewStringUTF (env, "");
 333   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 334   for (i = 0; i < r_len; ++i) {
 335     jstr = (*env)->NewStringUTF (env, r[i]);
 336     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 337     free (r[i]);
 338   }
 339   free (r);
 340   return jr;
 341 }
 342
 343 JNIEXPORT jobject JNICALL
 344 Java_com_redhat_et_libguestfs_GuestFS__1test0rintbool
 345   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 346 {
 347   guestfs_h *g = (guestfs_h *) (long) jg;
 348   jobject jr;
 349   jclass cl;
 350   jfieldID fl;
 351   struct guestfs_int_bool *r;
 352   const char *val;
 353
 354   val = (*env)->GetStringUTFChars (env, jval, NULL);
 355   r = guestfs_test0rintbool (g, val);
 356   (*env)->ReleaseStringUTFChars (env, jval, val);
 357   if (r == NULL) {
 358     throw_exception (env, guestfs_last_error (g));
 359     return NULL;
 360   }
 361   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 362   jr = (*env)->AllocObject (env, cl);
 363   fl = (*env)->GetFieldID (env, cl, "i", "I");
 364   (*env)->SetIntField (env, jr, fl, r->i);
 365   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 366   (*env)->SetBooleanField (env, jr, fl, r->b);
 367   guestfs_free_int_bool (r);
 368   return jr;
 369 }
 370
 371 JNIEXPORT jobject JNICALL
 372 Java_com_redhat_et_libguestfs_GuestFS__1test0rintboolerr
 373   (JNIEnv *env, jobject obj, jlong jg)
 374 {
 375   guestfs_h *g = (guestfs_h *) (long) jg;
 376   jobject jr;
 377   jclass cl;
 378   jfieldID fl;
 379   struct guestfs_int_bool *r;
 380
 381   r = guestfs_test0rintboolerr (g);
 382   if (r == NULL) {
 383     throw_exception (env, guestfs_last_error (g));
 384     return NULL;
 385   }
 386   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 387   jr = (*env)->AllocObject (env, cl);
 388   fl = (*env)->GetFieldID (env, cl, "i", "I");
 389   (*env)->SetIntField (env, jr, fl, r->i);
 390   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 391   (*env)->SetBooleanField (env, jr, fl, r->b);
 392   guestfs_free_int_bool (r);
 393   return jr;
 394 }
 395
 396 JNIEXPORT jobjectArray JNICALL
 397 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlist
 398   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 399 {
 400   guestfs_h *g = (guestfs_h *) (long) jg;
 401   jobjectArray jr;
 402   jclass cl;
 403   jfieldID fl;
 404   jobject jfl;
 405   struct guestfs_lvm_pv_list *r;
 406   const char *val;
 407   int i;
 408
 409   val = (*env)->GetStringUTFChars (env, jval, NULL);
 410   r = guestfs_test0rpvlist (g, val);
 411   (*env)->ReleaseStringUTFChars (env, jval, val);
 412   if (r == NULL) {
 413     throw_exception (env, guestfs_last_error (g));
 414     return NULL;
 415   }
 416   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 417   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 418   for (i = 0; i < r->len; ++i) {
 419     jfl = (*env)->AllocObject (env, cl);
 420     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 421     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 422     {
 423       char s[33];
 424       memcpy (s, r->val[i].pv_uuid, 32);
 425       s[32] = 0;
 426       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 427       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 428     }
 429     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 430     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 431     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 432     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 433     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 434     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 435     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 436     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 437     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 438     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 439     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 440     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 441     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 442     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 443     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 444     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 445     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 446     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 447     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 448     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 449     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 450     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 451     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 452     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 453     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 454   }
 455   guestfs_free_lvm_pv_list (r);
 456   return jr;
 457 }
 458
 459 JNIEXPORT jobjectArray JNICALL
 460 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlisterr
 461   (JNIEnv *env, jobject obj, jlong jg)
 462 {
 463   guestfs_h *g = (guestfs_h *) (long) jg;
 464   jobjectArray jr;
 465   jclass cl;
 466   jfieldID fl;
 467   jobject jfl;
 468   struct guestfs_lvm_pv_list *r;
 469   int i;
 470
 471   r = guestfs_test0rpvlisterr (g);
 472   if (r == NULL) {
 473     throw_exception (env, guestfs_last_error (g));
 474     return NULL;
 475   }
 476   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 477   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 478   for (i = 0; i < r->len; ++i) {
 479     jfl = (*env)->AllocObject (env, cl);
 480     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 481     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 482     {
 483       char s[33];
 484       memcpy (s, r->val[i].pv_uuid, 32);
 485       s[32] = 0;
 486       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 487       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 488     }
 489     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 490     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 491     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 492     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 493     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 494     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 495     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 496     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 497     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 498     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 499     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 500     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 501     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 502     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 503     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 504     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 505     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 506     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 507     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 508     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 509     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 510     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 511     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 512     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 513     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 514   }
 515   guestfs_free_lvm_pv_list (r);
 516   return jr;
 517 }
 518
 519 JNIEXPORT jobjectArray JNICALL
 520 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglist
 521   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 522 {
 523   guestfs_h *g = (guestfs_h *) (long) jg;
 524   jobjectArray jr;
 525   jclass cl;
 526   jfieldID fl;
 527   jobject jfl;
 528   struct guestfs_lvm_vg_list *r;
 529   const char *val;
 530   int i;
 531
 532   val = (*env)->GetStringUTFChars (env, jval, NULL);
 533   r = guestfs_test0rvglist (g, val);
 534   (*env)->ReleaseStringUTFChars (env, jval, val);
 535   if (r == NULL) {
 536     throw_exception (env, guestfs_last_error (g));
 537     return NULL;
 538   }
 539   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 540   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 541   for (i = 0; i < r->len; ++i) {
 542     jfl = (*env)->AllocObject (env, cl);
 543     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 544     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 545     {
 546       char s[33];
 547       memcpy (s, r->val[i].vg_uuid, 32);
 548       s[32] = 0;
 549       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 550       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 551     }
 552     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 553     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 554     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 555     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 556     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 557     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 558     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 559     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 560     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 561     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 562     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 563     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 564     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 565     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 566     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 567     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 568     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 569     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 570     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 571     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 572     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 573     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 574     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 575     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 576     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 577     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 578     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 579     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 580     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 581     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 582     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 583     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 584     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 585     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 586     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 587   }
 588   guestfs_free_lvm_vg_list (r);
 589   return jr;
 590 }
 591
 592 JNIEXPORT jobjectArray JNICALL
 593 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglisterr
 594   (JNIEnv *env, jobject obj, jlong jg)
 595 {
 596   guestfs_h *g = (guestfs_h *) (long) jg;
 597   jobjectArray jr;
 598   jclass cl;
 599   jfieldID fl;
 600   jobject jfl;
 601   struct guestfs_lvm_vg_list *r;
 602   int i;
 603
 604   r = guestfs_test0rvglisterr (g);
 605   if (r == NULL) {
 606     throw_exception (env, guestfs_last_error (g));
 607     return NULL;
 608   }
 609   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 610   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 611   for (i = 0; i < r->len; ++i) {
 612     jfl = (*env)->AllocObject (env, cl);
 613     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 614     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 615     {
 616       char s[33];
 617       memcpy (s, r->val[i].vg_uuid, 32);
 618       s[32] = 0;
 619       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 620       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 621     }
 622     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 623     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 624     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 625     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 626     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 627     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 628     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 629     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 630     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 631     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 632     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 633     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 634     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 635     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 636     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 637     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 638     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 639     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 640     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 641     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 642     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 643     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 644     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 645     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 646     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 647     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 648     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 649     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 650     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 651     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 652     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 653     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 654     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 655     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 656     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 657   }
 658   guestfs_free_lvm_vg_list (r);
 659   return jr;
 660 }
 661
 662 JNIEXPORT jobjectArray JNICALL
 663 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlist
 664   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 665 {
 666   guestfs_h *g = (guestfs_h *) (long) jg;
 667   jobjectArray jr;
 668   jclass cl;
 669   jfieldID fl;
 670   jobject jfl;
 671   struct guestfs_lvm_lv_list *r;
 672   const char *val;
 673   int i;
 674
 675   val = (*env)->GetStringUTFChars (env, jval, NULL);
 676   r = guestfs_test0rlvlist (g, val);
 677   (*env)->ReleaseStringUTFChars (env, jval, val);
 678   if (r == NULL) {
 679     throw_exception (env, guestfs_last_error (g));
 680     return NULL;
 681   }
 682   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
 683   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 684   for (i = 0; i < r->len; ++i) {
 685     jfl = (*env)->AllocObject (env, cl);
 686     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 687     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 688     {
 689       char s[33];
 690       memcpy (s, r->val[i].lv_uuid, 32);
 691       s[32] = 0;
 692       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 693       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 694     }
 695     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 696     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 697     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 698     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 699     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 700     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 701     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 702     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 703     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 704     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 705     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 706     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 707     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 708     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 709     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 710     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 711     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 712     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 713     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 714     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 715     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 716     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 717     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 718     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 719     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 720     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 721     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 722     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 723     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 724   }
 725   guestfs_free_lvm_lv_list (r);
 726   return jr;
 727 }
 728
 729 JNIEXPORT jobjectArray JNICALL
 730 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlisterr
 731   (JNIEnv *env, jobject obj, jlong jg)
 732 {
 733   guestfs_h *g = (guestfs_h *) (long) jg;
 734   jobjectArray jr;
 735   jclass cl;
 736   jfieldID fl;
 737   jobject jfl;
 738   struct guestfs_lvm_lv_list *r;
 739   int i;
 740
 741   r = guestfs_test0rlvlisterr (g);
 742   if (r == NULL) {
 743     throw_exception (env, guestfs_last_error (g));
 744     return NULL;
 745   }
 746   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
 747   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 748   for (i = 0; i < r->len; ++i) {
 749     jfl = (*env)->AllocObject (env, cl);
 750     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 751     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 752     {
 753       char s[33];
 754       memcpy (s, r->val[i].lv_uuid, 32);
 755       s[32] = 0;
 756       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 757       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 758     }
 759     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 760     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 761     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 762     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 763     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 764     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 765     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 766     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 767     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 768     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 769     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 770     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 771     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 772     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 773     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 774     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 775     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 776     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 777     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 778     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 779     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 780     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 781     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 782     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 783     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 784     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 785     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 786     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 787     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 788   }
 789   guestfs_free_lvm_lv_list (r);
 790   return jr;
 791 }
 792
 793 JNIEXPORT jobject JNICALL
 794 Java_com_redhat_et_libguestfs_GuestFS__1test0rstat
 795   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 796 {
 797   guestfs_h *g = (guestfs_h *) (long) jg;
 798   jobject jr;
 799   jclass cl;
 800   jfieldID fl;
 801   struct guestfs_stat *r;
 802   const char *val;
 803
 804   val = (*env)->GetStringUTFChars (env, jval, NULL);
 805   r = guestfs_test0rstat (g, val);
 806   (*env)->ReleaseStringUTFChars (env, jval, val);
 807   if (r == NULL) {
 808     throw_exception (env, guestfs_last_error (g));
 809     return NULL;
 810   }
 811   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
 812   jr = (*env)->AllocObject (env, cl);
 813   fl = (*env)->GetFieldID (env, cl, "dev", "J");
 814   (*env)->SetLongField (env, jr, fl, r->dev);
 815   fl = (*env)->GetFieldID (env, cl, "ino", "J");
 816   (*env)->SetLongField (env, jr, fl, r->ino);
 817   fl = (*env)->GetFieldID (env, cl, "mode", "J");
 818   (*env)->SetLongField (env, jr, fl, r->mode);
 819   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
 820   (*env)->SetLongField (env, jr, fl, r->nlink);
 821   fl = (*env)->GetFieldID (env, cl, "uid", "J");
 822   (*env)->SetLongField (env, jr, fl, r->uid);
 823   fl = (*env)->GetFieldID (env, cl, "gid", "J");
 824   (*env)->SetLongField (env, jr, fl, r->gid);
 825   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
 826   (*env)->SetLongField (env, jr, fl, r->rdev);
 827   fl = (*env)->GetFieldID (env, cl, "size", "J");
 828   (*env)->SetLongField (env, jr, fl, r->size);
 829   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
 830   (*env)->SetLongField (env, jr, fl, r->blksize);
 831   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 832   (*env)->SetLongField (env, jr, fl, r->blocks);
 833   fl = (*env)->GetFieldID (env, cl, "atime", "J");
 834   (*env)->SetLongField (env, jr, fl, r->atime);
 835   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
 836   (*env)->SetLongField (env, jr, fl, r->mtime);
 837   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
 838   (*env)->SetLongField (env, jr, fl, r->ctime);
 839   free (r);
 840   return jr;
 841 }
 842
 843 JNIEXPORT jobject JNICALL
 844 Java_com_redhat_et_libguestfs_GuestFS__1test0rstaterr
 845   (JNIEnv *env, jobject obj, jlong jg)
 846 {
 847   guestfs_h *g = (guestfs_h *) (long) jg;
 848   jobject jr;
 849   jclass cl;
 850   jfieldID fl;
 851   struct guestfs_stat *r;
 852
 853   r = guestfs_test0rstaterr (g);
 854   if (r == NULL) {
 855     throw_exception (env, guestfs_last_error (g));
 856     return NULL;
 857   }
 858   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
 859   jr = (*env)->AllocObject (env, cl);
 860   fl = (*env)->GetFieldID (env, cl, "dev", "J");
 861   (*env)->SetLongField (env, jr, fl, r->dev);
 862   fl = (*env)->GetFieldID (env, cl, "ino", "J");
 863   (*env)->SetLongField (env, jr, fl, r->ino);
 864   fl = (*env)->GetFieldID (env, cl, "mode", "J");
 865   (*env)->SetLongField (env, jr, fl, r->mode);
 866   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
 867   (*env)->SetLongField (env, jr, fl, r->nlink);
 868   fl = (*env)->GetFieldID (env, cl, "uid", "J");
 869   (*env)->SetLongField (env, jr, fl, r->uid);
 870   fl = (*env)->GetFieldID (env, cl, "gid", "J");
 871   (*env)->SetLongField (env, jr, fl, r->gid);
 872   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
 873   (*env)->SetLongField (env, jr, fl, r->rdev);
 874   fl = (*env)->GetFieldID (env, cl, "size", "J");
 875   (*env)->SetLongField (env, jr, fl, r->size);
 876   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
 877   (*env)->SetLongField (env, jr, fl, r->blksize);
 878   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 879   (*env)->SetLongField (env, jr, fl, r->blocks);
 880   fl = (*env)->GetFieldID (env, cl, "atime", "J");
 881   (*env)->SetLongField (env, jr, fl, r->atime);
 882   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
 883   (*env)->SetLongField (env, jr, fl, r->mtime);
 884   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
 885   (*env)->SetLongField (env, jr, fl, r->ctime);
 886   free (r);
 887   return jr;
 888 }
 889
 890 JNIEXPORT jobject JNICALL
 891 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfs
 892   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 893 {
 894   guestfs_h *g = (guestfs_h *) (long) jg;
 895   jobject jr;
 896   jclass cl;
 897   jfieldID fl;
 898   struct guestfs_statvfs *r;
 899   const char *val;
 900
 901   val = (*env)->GetStringUTFChars (env, jval, NULL);
 902   r = guestfs_test0rstatvfs (g, val);
 903   (*env)->ReleaseStringUTFChars (env, jval, val);
 904   if (r == NULL) {
 905     throw_exception (env, guestfs_last_error (g));
 906     return NULL;
 907   }
 908   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
 909   jr = (*env)->AllocObject (env, cl);
 910   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
 911   (*env)->SetLongField (env, jr, fl, r->bsize);
 912   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
 913   (*env)->SetLongField (env, jr, fl, r->frsize);
 914   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 915   (*env)->SetLongField (env, jr, fl, r->blocks);
 916   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
 917   (*env)->SetLongField (env, jr, fl, r->bfree);
 918   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
 919   (*env)->SetLongField (env, jr, fl, r->bavail);
 920   fl = (*env)->GetFieldID (env, cl, "files", "J");
 921   (*env)->SetLongField (env, jr, fl, r->files);
 922   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
 923   (*env)->SetLongField (env, jr, fl, r->ffree);
 924   fl = (*env)->GetFieldID (env, cl, "favail", "J");
 925   (*env)->SetLongField (env, jr, fl, r->favail);
 926   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
 927   (*env)->SetLongField (env, jr, fl, r->fsid);
 928   fl = (*env)->GetFieldID (env, cl, "flag", "J");
 929   (*env)->SetLongField (env, jr, fl, r->flag);
 930   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
 931   (*env)->SetLongField (env, jr, fl, r->namemax);
 932   free (r);
 933   return jr;
 934 }
 935
 936 JNIEXPORT jobject JNICALL
 937 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfserr
 938   (JNIEnv *env, jobject obj, jlong jg)
 939 {
 940   guestfs_h *g = (guestfs_h *) (long) jg;
 941   jobject jr;
 942   jclass cl;
 943   jfieldID fl;
 944   struct guestfs_statvfs *r;
 945
 946   r = guestfs_test0rstatvfserr (g);
 947   if (r == NULL) {
 948     throw_exception (env, guestfs_last_error (g));
 949     return NULL;
 950   }
 951   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
 952   jr = (*env)->AllocObject (env, cl);
 953   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
 954   (*env)->SetLongField (env, jr, fl, r->bsize);
 955   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
 956   (*env)->SetLongField (env, jr, fl, r->frsize);
 957   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 958   (*env)->SetLongField (env, jr, fl, r->blocks);
 959   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
 960   (*env)->SetLongField (env, jr, fl, r->bfree);
 961   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
 962   (*env)->SetLongField (env, jr, fl, r->bavail);
 963   fl = (*env)->GetFieldID (env, cl, "files", "J");
 964   (*env)->SetLongField (env, jr, fl, r->files);
 965   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
 966   (*env)->SetLongField (env, jr, fl, r->ffree);
 967   fl = (*env)->GetFieldID (env, cl, "favail", "J");
 968   (*env)->SetLongField (env, jr, fl, r->favail);
 969   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
 970   (*env)->SetLongField (env, jr, fl, r->fsid);
 971   fl = (*env)->GetFieldID (env, cl, "flag", "J");
 972   (*env)->SetLongField (env, jr, fl, r->flag);
 973   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
 974   (*env)->SetLongField (env, jr, fl, r->namemax);
 975   free (r);
 976   return jr;
 977 }
 978
 979 JNIEXPORT jobject JNICALL
 980 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtable
 981   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 982 {
 983   guestfs_h *g = (guestfs_h *) (long) jg;
 984   char **r;
 985   const char *val;
 986
 987   val = (*env)->GetStringUTFChars (env, jval, NULL);
 988   r = guestfs_test0rhashtable (g, val);
 989   (*env)->ReleaseStringUTFChars (env, jval, val);
 990   if (r == NULL) {
 991     throw_exception (env, guestfs_last_error (g));
 992     return NULL;
 993   }
 994   throw_exception (env, "test0rhashtable: internal error: please let us know how to make a Java HashMap from JNI bindings!");
 995   return NULL;
 996 }
 997
 998 JNIEXPORT jobject JNICALL
 999 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtableerr
1000   (JNIEnv *env, jobject obj, jlong jg)
1001 {
1002   guestfs_h *g = (guestfs_h *) (long) jg;
1003   char **r;
1004
1005   r = guestfs_test0rhashtableerr (g);
1006   if (r == NULL) {
1007     throw_exception (env, guestfs_last_error (g));
1008     return NULL;
1009   }
1010   throw_exception (env, "test0rhashtableerr: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1011   return NULL;
1012 }
1013
1014 JNIEXPORT void JNICALL
1015 Java_com_redhat_et_libguestfs_GuestFS__1launch
1016   (JNIEnv *env, jobject obj, jlong jg)
1017 {
1018   guestfs_h *g = (guestfs_h *) (long) jg;
1019   int r;
1020
1021   r = guestfs_launch (g);
1022   if (r == -1) {
1023     throw_exception (env, guestfs_last_error (g));
1024     return ;
1025   }
1026 }
1027
1028 JNIEXPORT void JNICALL
1029 Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
1030   (JNIEnv *env, jobject obj, jlong jg)
1031 {
1032   guestfs_h *g = (guestfs_h *) (long) jg;
1033   int r;
1034
1035   r = guestfs_wait_ready (g);
1036   if (r == -1) {
1037     throw_exception (env, guestfs_last_error (g));
1038     return ;
1039   }
1040 }
1041
1042 JNIEXPORT void JNICALL
1043 Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
1044   (JNIEnv *env, jobject obj, jlong jg)
1045 {
1046   guestfs_h *g = (guestfs_h *) (long) jg;
1047   int r;
1048
1049   r = guestfs_kill_subprocess (g);
1050   if (r == -1) {
1051     throw_exception (env, guestfs_last_error (g));
1052     return ;
1053   }
1054 }
1055
1056 JNIEXPORT void JNICALL
1057 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
1058   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1059 {
1060   guestfs_h *g = (guestfs_h *) (long) jg;
1061   int r;
1062   const char *filename;
1063
1064   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1065   r = guestfs_add_drive (g, filename);
1066   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1067   if (r == -1) {
1068     throw_exception (env, guestfs_last_error (g));
1069     return ;
1070   }
1071 }
1072
1073 JNIEXPORT void JNICALL
1074 Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
1075   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1076 {
1077   guestfs_h *g = (guestfs_h *) (long) jg;
1078   int r;
1079   const char *filename;
1080
1081   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1082   r = guestfs_add_cdrom (g, filename);
1083   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1084   if (r == -1) {
1085     throw_exception (env, guestfs_last_error (g));
1086     return ;
1087   }
1088 }
1089
1090 JNIEXPORT void JNICALL
1091 Java_com_redhat_et_libguestfs_GuestFS__1config
1092   (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
1093 {
1094   guestfs_h *g = (guestfs_h *) (long) jg;
1095   int r;
1096   const char *qemuparam;
1097   const char *qemuvalue;
1098
1099   qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
1100   qemuvalue = (*env)->GetStringUTFChars (env, jqemuvalue, NULL);
1101   r = guestfs_config (g, qemuparam, qemuvalue);
1102   (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
1103   (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
1104   if (r == -1) {
1105     throw_exception (env, guestfs_last_error (g));
1106     return ;
1107   }
1108 }
1109
1110 JNIEXPORT void JNICALL
1111 Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
1112   (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
1113 {
1114   guestfs_h *g = (guestfs_h *) (long) jg;
1115   int r;
1116   const char *qemu;
1117
1118   qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
1119   r = guestfs_set_qemu (g, qemu);
1120   (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
1121   if (r == -1) {
1122     throw_exception (env, guestfs_last_error (g));
1123     return ;
1124   }
1125 }
1126
1127 JNIEXPORT jstring JNICALL
1128 Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
1129   (JNIEnv *env, jobject obj, jlong jg)
1130 {
1131   guestfs_h *g = (guestfs_h *) (long) jg;
1132   const char *r;
1133
1134   r = guestfs_get_qemu (g);
1135   if (r == NULL) {
1136     throw_exception (env, guestfs_last_error (g));
1137     return NULL;
1138   }
1139   return (*env)->NewStringUTF (env, r);
1140 }
1141
1142 JNIEXPORT void JNICALL
1143 Java_com_redhat_et_libguestfs_GuestFS__1set_1path
1144   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1145 {
1146   guestfs_h *g = (guestfs_h *) (long) jg;
1147   int r;
1148   const char *path;
1149
1150   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1151   r = guestfs_set_path (g, path);
1152   (*env)->ReleaseStringUTFChars (env, jpath, path);
1153   if (r == -1) {
1154     throw_exception (env, guestfs_last_error (g));
1155     return ;
1156   }
1157 }
1158
1159 JNIEXPORT jstring JNICALL
1160 Java_com_redhat_et_libguestfs_GuestFS__1get_1path
1161   (JNIEnv *env, jobject obj, jlong jg)
1162 {
1163   guestfs_h *g = (guestfs_h *) (long) jg;
1164   const char *r;
1165
1166   r = guestfs_get_path (g);
1167   if (r == NULL) {
1168     throw_exception (env, guestfs_last_error (g));
1169     return NULL;
1170   }
1171   return (*env)->NewStringUTF (env, r);
1172 }
1173
1174 JNIEXPORT void JNICALL
1175 Java_com_redhat_et_libguestfs_GuestFS__1set_1append
1176   (JNIEnv *env, jobject obj, jlong jg, jstring jappend)
1177 {
1178   guestfs_h *g = (guestfs_h *) (long) jg;
1179   int r;
1180   const char *append;
1181
1182   append = (*env)->GetStringUTFChars (env, jappend, NULL);
1183   r = guestfs_set_append (g, append);
1184   (*env)->ReleaseStringUTFChars (env, jappend, append);
1185   if (r == -1) {
1186     throw_exception (env, guestfs_last_error (g));
1187     return ;
1188   }
1189 }
1190
1191 JNIEXPORT jstring JNICALL
1192 Java_com_redhat_et_libguestfs_GuestFS__1get_1append
1193   (JNIEnv *env, jobject obj, jlong jg)
1194 {
1195   guestfs_h *g = (guestfs_h *) (long) jg;
1196   const char *r;
1197
1198   r = guestfs_get_append (g);
1199   if (r == NULL) {
1200     throw_exception (env, guestfs_last_error (g));
1201     return NULL;
1202   }
1203   return (*env)->NewStringUTF (env, r);
1204 }
1205
1206 JNIEXPORT void JNICALL
1207 Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
1208   (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
1209 {
1210   guestfs_h *g = (guestfs_h *) (long) jg;
1211   int r;
1212   int autosync;
1213
1214   autosync = jautosync;
1215   r = guestfs_set_autosync (g, autosync);
1216   if (r == -1) {
1217     throw_exception (env, guestfs_last_error (g));
1218     return ;
1219   }
1220 }
1221
1222 JNIEXPORT jboolean JNICALL
1223 Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
1224   (JNIEnv *env, jobject obj, jlong jg)
1225 {
1226   guestfs_h *g = (guestfs_h *) (long) jg;
1227   int r;
1228
1229   r = guestfs_get_autosync (g);
1230   if (r == -1) {
1231     throw_exception (env, guestfs_last_error (g));
1232     return 0;
1233   }
1234   return (jboolean) r;
1235 }
1236
1237 JNIEXPORT void JNICALL
1238 Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
1239   (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
1240 {
1241   guestfs_h *g = (guestfs_h *) (long) jg;
1242   int r;
1243   int verbose;
1244
1245   verbose = jverbose;
1246   r = guestfs_set_verbose (g, verbose);
1247   if (r == -1) {
1248     throw_exception (env, guestfs_last_error (g));
1249     return ;
1250   }
1251 }
1252
1253 JNIEXPORT jboolean JNICALL
1254 Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
1255   (JNIEnv *env, jobject obj, jlong jg)
1256 {
1257   guestfs_h *g = (guestfs_h *) (long) jg;
1258   int r;
1259
1260   r = guestfs_get_verbose (g);
1261   if (r == -1) {
1262     throw_exception (env, guestfs_last_error (g));
1263     return 0;
1264   }
1265   return (jboolean) r;
1266 }
1267
1268 JNIEXPORT jboolean JNICALL
1269 Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
1270   (JNIEnv *env, jobject obj, jlong jg)
1271 {
1272   guestfs_h *g = (guestfs_h *) (long) jg;
1273   int r;
1274
1275   r = guestfs_is_ready (g);
1276   if (r == -1) {
1277     throw_exception (env, guestfs_last_error (g));
1278     return 0;
1279   }
1280   return (jboolean) r;
1281 }
1282
1283 JNIEXPORT jboolean JNICALL
1284 Java_com_redhat_et_libguestfs_GuestFS__1is_1config
1285   (JNIEnv *env, jobject obj, jlong jg)
1286 {
1287   guestfs_h *g = (guestfs_h *) (long) jg;
1288   int r;
1289
1290   r = guestfs_is_config (g);
1291   if (r == -1) {
1292     throw_exception (env, guestfs_last_error (g));
1293     return 0;
1294   }
1295   return (jboolean) r;
1296 }
1297
1298 JNIEXPORT jboolean JNICALL
1299 Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
1300   (JNIEnv *env, jobject obj, jlong jg)
1301 {
1302   guestfs_h *g = (guestfs_h *) (long) jg;
1303   int r;
1304
1305   r = guestfs_is_launching (g);
1306   if (r == -1) {
1307     throw_exception (env, guestfs_last_error (g));
1308     return 0;
1309   }
1310   return (jboolean) r;
1311 }
1312
1313 JNIEXPORT jboolean JNICALL
1314 Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
1315   (JNIEnv *env, jobject obj, jlong jg)
1316 {
1317   guestfs_h *g = (guestfs_h *) (long) jg;
1318   int r;
1319
1320   r = guestfs_is_busy (g);
1321   if (r == -1) {
1322     throw_exception (env, guestfs_last_error (g));
1323     return 0;
1324   }
1325   return (jboolean) r;
1326 }
1327
1328 JNIEXPORT jint JNICALL
1329 Java_com_redhat_et_libguestfs_GuestFS__1get_1state
1330   (JNIEnv *env, jobject obj, jlong jg)
1331 {
1332   guestfs_h *g = (guestfs_h *) (long) jg;
1333   int r;
1334
1335   r = guestfs_get_state (g);
1336   if (r == -1) {
1337     throw_exception (env, guestfs_last_error (g));
1338     return 0;
1339   }
1340   return (jint) r;
1341 }
1342
1343 JNIEXPORT void JNICALL
1344 Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
1345   (JNIEnv *env, jobject obj, jlong jg)
1346 {
1347   guestfs_h *g = (guestfs_h *) (long) jg;
1348   int r;
1349
1350   r = guestfs_set_busy (g);
1351   if (r == -1) {
1352     throw_exception (env, guestfs_last_error (g));
1353     return ;
1354   }
1355 }
1356
1357 JNIEXPORT void JNICALL
1358 Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
1359   (JNIEnv *env, jobject obj, jlong jg)
1360 {
1361   guestfs_h *g = (guestfs_h *) (long) jg;
1362   int r;
1363
1364   r = guestfs_set_ready (g);
1365   if (r == -1) {
1366     throw_exception (env, guestfs_last_error (g));
1367     return ;
1368   }
1369 }
1370
1371 JNIEXPORT void JNICALL
1372 Java_com_redhat_et_libguestfs_GuestFS__1end_1busy
1373   (JNIEnv *env, jobject obj, jlong jg)
1374 {
1375   guestfs_h *g = (guestfs_h *) (long) jg;
1376   int r;
1377
1378   r = guestfs_end_busy (g);
1379   if (r == -1) {
1380     throw_exception (env, guestfs_last_error (g));
1381     return ;
1382   }
1383 }
1384
1385 JNIEXPORT void JNICALL
1386 Java_com_redhat_et_libguestfs_GuestFS__1mount
1387   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
1388 {
1389   guestfs_h *g = (guestfs_h *) (long) jg;
1390   int r;
1391   const char *device;
1392   const char *mountpoint;
1393
1394   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1395   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
1396   r = guestfs_mount (g, device, mountpoint);
1397   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1398   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
1399   if (r == -1) {
1400     throw_exception (env, guestfs_last_error (g));
1401     return ;
1402   }
1403 }
1404
1405 JNIEXPORT void JNICALL
1406 Java_com_redhat_et_libguestfs_GuestFS__1sync
1407   (JNIEnv *env, jobject obj, jlong jg)
1408 {
1409   guestfs_h *g = (guestfs_h *) (long) jg;
1410   int r;
1411
1412   r = guestfs_sync (g);
1413   if (r == -1) {
1414     throw_exception (env, guestfs_last_error (g));
1415     return ;
1416   }
1417 }
1418
1419 JNIEXPORT void JNICALL
1420 Java_com_redhat_et_libguestfs_GuestFS__1touch
1421   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1422 {
1423   guestfs_h *g = (guestfs_h *) (long) jg;
1424   int r;
1425   const char *path;
1426
1427   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1428   r = guestfs_touch (g, path);
1429   (*env)->ReleaseStringUTFChars (env, jpath, path);
1430   if (r == -1) {
1431     throw_exception (env, guestfs_last_error (g));
1432     return ;
1433   }
1434 }
1435
1436 JNIEXPORT jstring JNICALL
1437 Java_com_redhat_et_libguestfs_GuestFS__1cat
1438   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1439 {
1440   guestfs_h *g = (guestfs_h *) (long) jg;
1441   jstring jr;
1442   char *r;
1443   const char *path;
1444
1445   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1446   r = guestfs_cat (g, path);
1447   (*env)->ReleaseStringUTFChars (env, jpath, path);
1448   if (r == NULL) {
1449     throw_exception (env, guestfs_last_error (g));
1450     return NULL;
1451   }
1452   jr = (*env)->NewStringUTF (env, r);
1453   free (r);
1454   return jr;
1455 }
1456
1457 JNIEXPORT jstring JNICALL
1458 Java_com_redhat_et_libguestfs_GuestFS__1ll
1459   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1460 {
1461   guestfs_h *g = (guestfs_h *) (long) jg;
1462   jstring jr;
1463   char *r;
1464   const char *directory;
1465
1466   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1467   r = guestfs_ll (g, directory);
1468   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1469   if (r == NULL) {
1470     throw_exception (env, guestfs_last_error (g));
1471     return NULL;
1472   }
1473   jr = (*env)->NewStringUTF (env, r);
1474   free (r);
1475   return jr;
1476 }
1477
1478 JNIEXPORT jobjectArray JNICALL
1479 Java_com_redhat_et_libguestfs_GuestFS__1ls
1480   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1481 {
1482   guestfs_h *g = (guestfs_h *) (long) jg;
1483   jobjectArray jr;
1484   int r_len;
1485   jclass cl;
1486   jstring jstr;
1487   char **r;
1488   const char *directory;
1489   int i;
1490
1491   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1492   r = guestfs_ls (g, directory);
1493   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1494   if (r == NULL) {
1495     throw_exception (env, guestfs_last_error (g));
1496     return NULL;
1497   }
1498   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1499   cl = (*env)->FindClass (env, "java/lang/String");
1500   jstr = (*env)->NewStringUTF (env, "");
1501   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1502   for (i = 0; i < r_len; ++i) {
1503     jstr = (*env)->NewStringUTF (env, r[i]);
1504     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1505     free (r[i]);
1506   }
1507   free (r);
1508   return jr;
1509 }
1510
1511 JNIEXPORT jobjectArray JNICALL
1512 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
1513   (JNIEnv *env, jobject obj, jlong jg)
1514 {
1515   guestfs_h *g = (guestfs_h *) (long) jg;
1516   jobjectArray jr;
1517   int r_len;
1518   jclass cl;
1519   jstring jstr;
1520   char **r;
1521   int i;
1522
1523   r = guestfs_list_devices (g);
1524   if (r == NULL) {
1525     throw_exception (env, guestfs_last_error (g));
1526     return NULL;
1527   }
1528   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1529   cl = (*env)->FindClass (env, "java/lang/String");
1530   jstr = (*env)->NewStringUTF (env, "");
1531   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1532   for (i = 0; i < r_len; ++i) {
1533     jstr = (*env)->NewStringUTF (env, r[i]);
1534     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1535     free (r[i]);
1536   }
1537   free (r);
1538   return jr;
1539 }
1540
1541 JNIEXPORT jobjectArray JNICALL
1542 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
1543   (JNIEnv *env, jobject obj, jlong jg)
1544 {
1545   guestfs_h *g = (guestfs_h *) (long) jg;
1546   jobjectArray jr;
1547   int r_len;
1548   jclass cl;
1549   jstring jstr;
1550   char **r;
1551   int i;
1552
1553   r = guestfs_list_partitions (g);
1554   if (r == NULL) {
1555     throw_exception (env, guestfs_last_error (g));
1556     return NULL;
1557   }
1558   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1559   cl = (*env)->FindClass (env, "java/lang/String");
1560   jstr = (*env)->NewStringUTF (env, "");
1561   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1562   for (i = 0; i < r_len; ++i) {
1563     jstr = (*env)->NewStringUTF (env, r[i]);
1564     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1565     free (r[i]);
1566   }
1567   free (r);
1568   return jr;
1569 }
1570
1571 JNIEXPORT jobjectArray JNICALL
1572 Java_com_redhat_et_libguestfs_GuestFS__1pvs
1573   (JNIEnv *env, jobject obj, jlong jg)
1574 {
1575   guestfs_h *g = (guestfs_h *) (long) jg;
1576   jobjectArray jr;
1577   int r_len;
1578   jclass cl;
1579   jstring jstr;
1580   char **r;
1581   int i;
1582
1583   r = guestfs_pvs (g);
1584   if (r == NULL) {
1585     throw_exception (env, guestfs_last_error (g));
1586     return NULL;
1587   }
1588   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1589   cl = (*env)->FindClass (env, "java/lang/String");
1590   jstr = (*env)->NewStringUTF (env, "");
1591   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1592   for (i = 0; i < r_len; ++i) {
1593     jstr = (*env)->NewStringUTF (env, r[i]);
1594     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1595     free (r[i]);
1596   }
1597   free (r);
1598   return jr;
1599 }
1600
1601 JNIEXPORT jobjectArray JNICALL
1602 Java_com_redhat_et_libguestfs_GuestFS__1vgs
1603   (JNIEnv *env, jobject obj, jlong jg)
1604 {
1605   guestfs_h *g = (guestfs_h *) (long) jg;
1606   jobjectArray jr;
1607   int r_len;
1608   jclass cl;
1609   jstring jstr;
1610   char **r;
1611   int i;
1612
1613   r = guestfs_vgs (g);
1614   if (r == NULL) {
1615     throw_exception (env, guestfs_last_error (g));
1616     return NULL;
1617   }
1618   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1619   cl = (*env)->FindClass (env, "java/lang/String");
1620   jstr = (*env)->NewStringUTF (env, "");
1621   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1622   for (i = 0; i < r_len; ++i) {
1623     jstr = (*env)->NewStringUTF (env, r[i]);
1624     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1625     free (r[i]);
1626   }
1627   free (r);
1628   return jr;
1629 }
1630
1631 JNIEXPORT jobjectArray JNICALL
1632 Java_com_redhat_et_libguestfs_GuestFS__1lvs
1633   (JNIEnv *env, jobject obj, jlong jg)
1634 {
1635   guestfs_h *g = (guestfs_h *) (long) jg;
1636   jobjectArray jr;
1637   int r_len;
1638   jclass cl;
1639   jstring jstr;
1640   char **r;
1641   int i;
1642
1643   r = guestfs_lvs (g);
1644   if (r == NULL) {
1645     throw_exception (env, guestfs_last_error (g));
1646     return NULL;
1647   }
1648   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1649   cl = (*env)->FindClass (env, "java/lang/String");
1650   jstr = (*env)->NewStringUTF (env, "");
1651   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1652   for (i = 0; i < r_len; ++i) {
1653     jstr = (*env)->NewStringUTF (env, r[i]);
1654     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1655     free (r[i]);
1656   }
1657   free (r);
1658   return jr;
1659 }
1660
1661 JNIEXPORT jobjectArray JNICALL
1662 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
1663   (JNIEnv *env, jobject obj, jlong jg)
1664 {
1665   guestfs_h *g = (guestfs_h *) (long) jg;
1666   jobjectArray jr;
1667   jclass cl;
1668   jfieldID fl;
1669   jobject jfl;
1670   struct guestfs_lvm_pv_list *r;
1671   int i;
1672
1673   r = guestfs_pvs_full (g);
1674   if (r == NULL) {
1675     throw_exception (env, guestfs_last_error (g));
1676     return NULL;
1677   }
1678   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
1679   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1680   for (i = 0; i < r->len; ++i) {
1681     jfl = (*env)->AllocObject (env, cl);
1682     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
1683     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
1684     {
1685       char s[33];
1686       memcpy (s, r->val[i].pv_uuid, 32);
1687       s[32] = 0;
1688       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
1689       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1690     }
1691     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
1692     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
1693     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
1694     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
1695     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
1696     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
1697     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
1698     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
1699     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
1700     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
1701     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
1702     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
1703     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
1704     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
1705     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
1706     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
1707     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
1708     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
1709     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
1710     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
1711     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
1712     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
1713     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
1714     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
1715     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1716   }
1717   guestfs_free_lvm_pv_list (r);
1718   return jr;
1719 }
1720
1721 JNIEXPORT jobjectArray JNICALL
1722 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
1723   (JNIEnv *env, jobject obj, jlong jg)
1724 {
1725   guestfs_h *g = (guestfs_h *) (long) jg;
1726   jobjectArray jr;
1727   jclass cl;
1728   jfieldID fl;
1729   jobject jfl;
1730   struct guestfs_lvm_vg_list *r;
1731   int i;
1732
1733   r = guestfs_vgs_full (g);
1734   if (r == NULL) {
1735     throw_exception (env, guestfs_last_error (g));
1736     return NULL;
1737   }
1738   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
1739   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1740   for (i = 0; i < r->len; ++i) {
1741     jfl = (*env)->AllocObject (env, cl);
1742     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
1743     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
1744     {
1745       char s[33];
1746       memcpy (s, r->val[i].vg_uuid, 32);
1747       s[32] = 0;
1748       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
1749       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1750     }
1751     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
1752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
1753     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
1754     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
1755     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
1756     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
1757     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
1758     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
1759     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
1760     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
1761     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
1762     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
1763     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
1764     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
1765     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
1766     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
1767     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
1768     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
1769     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
1770     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
1771     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
1772     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
1773     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
1774     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
1775     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
1776     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
1777     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
1778     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
1779     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
1780     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
1781     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
1782     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
1783     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
1784     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
1785     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1786   }
1787   guestfs_free_lvm_vg_list (r);
1788   return jr;
1789 }
1790
1791 JNIEXPORT jobjectArray JNICALL
1792 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
1793   (JNIEnv *env, jobject obj, jlong jg)
1794 {
1795   guestfs_h *g = (guestfs_h *) (long) jg;
1796   jobjectArray jr;
1797   jclass cl;
1798   jfieldID fl;
1799   jobject jfl;
1800   struct guestfs_lvm_lv_list *r;
1801   int i;
1802
1803   r = guestfs_lvs_full (g);
1804   if (r == NULL) {
1805     throw_exception (env, guestfs_last_error (g));
1806     return NULL;
1807   }
1808   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
1809   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1810   for (i = 0; i < r->len; ++i) {
1811     jfl = (*env)->AllocObject (env, cl);
1812     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
1813     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
1814     {
1815       char s[33];
1816       memcpy (s, r->val[i].lv_uuid, 32);
1817       s[32] = 0;
1818       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
1819       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1820     }
1821     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
1822     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
1823     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
1824     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
1825     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
1826     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
1827     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
1828     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
1829     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
1830     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
1831     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
1832     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
1833     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
1834     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
1835     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
1836     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
1837     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
1838     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
1839     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
1840     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
1841     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
1842     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
1843     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
1844     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
1845     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
1846     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
1847     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
1848     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
1849     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1850   }
1851   guestfs_free_lvm_lv_list (r);
1852   return jr;
1853 }
1854
1855 JNIEXPORT jobjectArray JNICALL
1856 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
1857   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1858 {
1859   guestfs_h *g = (guestfs_h *) (long) jg;
1860   jobjectArray jr;
1861   int r_len;
1862   jclass cl;
1863   jstring jstr;
1864   char **r;
1865   const char *path;
1866   int i;
1867
1868   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1869   r = guestfs_read_lines (g, path);
1870   (*env)->ReleaseStringUTFChars (env, jpath, path);
1871   if (r == NULL) {
1872     throw_exception (env, guestfs_last_error (g));
1873     return NULL;
1874   }
1875   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1876   cl = (*env)->FindClass (env, "java/lang/String");
1877   jstr = (*env)->NewStringUTF (env, "");
1878   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1879   for (i = 0; i < r_len; ++i) {
1880     jstr = (*env)->NewStringUTF (env, r[i]);
1881     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1882     free (r[i]);
1883   }
1884   free (r);
1885   return jr;
1886 }
1887
1888 JNIEXPORT void JNICALL
1889 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
1890   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
1891 {
1892   guestfs_h *g = (guestfs_h *) (long) jg;
1893   int r;
1894   const char *root;
1895   int flags;
1896
1897   root = (*env)->GetStringUTFChars (env, jroot, NULL);
1898   flags = jflags;
1899   r = guestfs_aug_init (g, root, flags);
1900   (*env)->ReleaseStringUTFChars (env, jroot, root);
1901   if (r == -1) {
1902     throw_exception (env, guestfs_last_error (g));
1903     return ;
1904   }
1905 }
1906
1907 JNIEXPORT void JNICALL
1908 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
1909   (JNIEnv *env, jobject obj, jlong jg)
1910 {
1911   guestfs_h *g = (guestfs_h *) (long) jg;
1912   int r;
1913
1914   r = guestfs_aug_close (g);
1915   if (r == -1) {
1916     throw_exception (env, guestfs_last_error (g));
1917     return ;
1918   }
1919 }
1920
1921 JNIEXPORT jint JNICALL
1922 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
1923   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
1924 {
1925   guestfs_h *g = (guestfs_h *) (long) jg;
1926   int r;
1927   const char *name;
1928   const char *expr;
1929
1930   name = (*env)->GetStringUTFChars (env, jname, NULL);
1931   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
1932   r = guestfs_aug_defvar (g, name, expr);
1933   (*env)->ReleaseStringUTFChars (env, jname, name);
1934   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1935   if (r == -1) {
1936     throw_exception (env, guestfs_last_error (g));
1937     return 0;
1938   }
1939   return (jint) r;
1940 }
1941
1942 JNIEXPORT jobject JNICALL
1943 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
1944   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
1945 {
1946   guestfs_h *g = (guestfs_h *) (long) jg;
1947   jobject jr;
1948   jclass cl;
1949   jfieldID fl;
1950   struct guestfs_int_bool *r;
1951   const char *name;
1952   const char *expr;
1953   const char *val;
1954
1955   name = (*env)->GetStringUTFChars (env, jname, NULL);
1956   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
1957   val = (*env)->GetStringUTFChars (env, jval, NULL);
1958   r = guestfs_aug_defnode (g, name, expr, val);
1959   (*env)->ReleaseStringUTFChars (env, jname, name);
1960   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1961   (*env)->ReleaseStringUTFChars (env, jval, val);
1962   if (r == NULL) {
1963     throw_exception (env, guestfs_last_error (g));
1964     return NULL;
1965   }
1966   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
1967   jr = (*env)->AllocObject (env, cl);
1968   fl = (*env)->GetFieldID (env, cl, "i", "I");
1969   (*env)->SetIntField (env, jr, fl, r->i);
1970   fl = (*env)->GetFieldID (env, cl, "i", "Z");
1971   (*env)->SetBooleanField (env, jr, fl, r->b);
1972   guestfs_free_int_bool (r);
1973   return jr;
1974 }
1975
1976 JNIEXPORT jstring JNICALL
1977 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
1978   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1979 {
1980   guestfs_h *g = (guestfs_h *) (long) jg;
1981   jstring jr;
1982   char *r;
1983   const char *path;
1984
1985   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1986   r = guestfs_aug_get (g, path);
1987   (*env)->ReleaseStringUTFChars (env, jpath, path);
1988   if (r == NULL) {
1989     throw_exception (env, guestfs_last_error (g));
1990     return NULL;
1991   }
1992   jr = (*env)->NewStringUTF (env, r);
1993   free (r);
1994   return jr;
1995 }
1996
1997 JNIEXPORT void JNICALL
1998 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
1999   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
2000 {
2001   guestfs_h *g = (guestfs_h *) (long) jg;
2002   int r;
2003   const char *path;
2004   const char *val;
2005
2006   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2007   val = (*env)->GetStringUTFChars (env, jval, NULL);
2008   r = guestfs_aug_set (g, path, val);
2009   (*env)->ReleaseStringUTFChars (env, jpath, path);
2010   (*env)->ReleaseStringUTFChars (env, jval, val);
2011   if (r == -1) {
2012     throw_exception (env, guestfs_last_error (g));
2013     return ;
2014   }
2015 }
2016
2017 JNIEXPORT void JNICALL
2018 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
2019   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
2020 {
2021   guestfs_h *g = (guestfs_h *) (long) jg;
2022   int r;
2023   const char *path;
2024   const char *label;
2025   int before;
2026
2027   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2028   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2029   before = jbefore;
2030   r = guestfs_aug_insert (g, path, label, before);
2031   (*env)->ReleaseStringUTFChars (env, jpath, path);
2032   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2033   if (r == -1) {
2034     throw_exception (env, guestfs_last_error (g));
2035     return ;
2036   }
2037 }
2038
2039 JNIEXPORT jint JNICALL
2040 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
2041   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2042 {
2043   guestfs_h *g = (guestfs_h *) (long) jg;
2044   int r;
2045   const char *path;
2046
2047   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2048   r = guestfs_aug_rm (g, path);
2049   (*env)->ReleaseStringUTFChars (env, jpath, path);
2050   if (r == -1) {
2051     throw_exception (env, guestfs_last_error (g));
2052     return 0;
2053   }
2054   return (jint) r;
2055 }
2056
2057 JNIEXPORT void JNICALL
2058 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
2059   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2060 {
2061   guestfs_h *g = (guestfs_h *) (long) jg;
2062   int r;
2063   const char *src;
2064   const char *dest;
2065
2066   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2067   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2068   r = guestfs_aug_mv (g, src, dest);
2069   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2070   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2071   if (r == -1) {
2072     throw_exception (env, guestfs_last_error (g));
2073     return ;
2074   }
2075 }
2076
2077 JNIEXPORT jobjectArray JNICALL
2078 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
2079   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2080 {
2081   guestfs_h *g = (guestfs_h *) (long) jg;
2082   jobjectArray jr;
2083   int r_len;
2084   jclass cl;
2085   jstring jstr;
2086   char **r;
2087   const char *path;
2088   int i;
2089
2090   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2091   r = guestfs_aug_match (g, path);
2092   (*env)->ReleaseStringUTFChars (env, jpath, path);
2093   if (r == NULL) {
2094     throw_exception (env, guestfs_last_error (g));
2095     return NULL;
2096   }
2097   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2098   cl = (*env)->FindClass (env, "java/lang/String");
2099   jstr = (*env)->NewStringUTF (env, "");
2100   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2101   for (i = 0; i < r_len; ++i) {
2102     jstr = (*env)->NewStringUTF (env, r[i]);
2103     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2104     free (r[i]);
2105   }
2106   free (r);
2107   return jr;
2108 }
2109
2110 JNIEXPORT void JNICALL
2111 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
2112   (JNIEnv *env, jobject obj, jlong jg)
2113 {
2114   guestfs_h *g = (guestfs_h *) (long) jg;
2115   int r;
2116
2117   r = guestfs_aug_save (g);
2118   if (r == -1) {
2119     throw_exception (env, guestfs_last_error (g));
2120     return ;
2121   }
2122 }
2123
2124 JNIEXPORT void JNICALL
2125 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
2126   (JNIEnv *env, jobject obj, jlong jg)
2127 {
2128   guestfs_h *g = (guestfs_h *) (long) jg;
2129   int r;
2130
2131   r = guestfs_aug_load (g);
2132   if (r == -1) {
2133     throw_exception (env, guestfs_last_error (g));
2134     return ;
2135   }
2136 }
2137
2138 JNIEXPORT jobjectArray JNICALL
2139 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
2140   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2141 {
2142   guestfs_h *g = (guestfs_h *) (long) jg;
2143   jobjectArray jr;
2144   int r_len;
2145   jclass cl;
2146   jstring jstr;
2147   char **r;
2148   const char *path;
2149   int i;
2150
2151   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2152   r = guestfs_aug_ls (g, path);
2153   (*env)->ReleaseStringUTFChars (env, jpath, path);
2154   if (r == NULL) {
2155     throw_exception (env, guestfs_last_error (g));
2156     return NULL;
2157   }
2158   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2159   cl = (*env)->FindClass (env, "java/lang/String");
2160   jstr = (*env)->NewStringUTF (env, "");
2161   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2162   for (i = 0; i < r_len; ++i) {
2163     jstr = (*env)->NewStringUTF (env, r[i]);
2164     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2165     free (r[i]);
2166   }
2167   free (r);
2168   return jr;
2169 }
2170
2171 JNIEXPORT void JNICALL
2172 Java_com_redhat_et_libguestfs_GuestFS__1rm
2173   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2174 {
2175   guestfs_h *g = (guestfs_h *) (long) jg;
2176   int r;
2177   const char *path;
2178
2179   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2180   r = guestfs_rm (g, path);
2181   (*env)->ReleaseStringUTFChars (env, jpath, path);
2182   if (r == -1) {
2183     throw_exception (env, guestfs_last_error (g));
2184     return ;
2185   }
2186 }
2187
2188 JNIEXPORT void JNICALL
2189 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
2190   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2191 {
2192   guestfs_h *g = (guestfs_h *) (long) jg;
2193   int r;
2194   const char *path;
2195
2196   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2197   r = guestfs_rmdir (g, path);
2198   (*env)->ReleaseStringUTFChars (env, jpath, path);
2199   if (r == -1) {
2200     throw_exception (env, guestfs_last_error (g));
2201     return ;
2202   }
2203 }
2204
2205 JNIEXPORT void JNICALL
2206 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
2207   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2208 {
2209   guestfs_h *g = (guestfs_h *) (long) jg;
2210   int r;
2211   const char *path;
2212
2213   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2214   r = guestfs_rm_rf (g, path);
2215   (*env)->ReleaseStringUTFChars (env, jpath, path);
2216   if (r == -1) {
2217     throw_exception (env, guestfs_last_error (g));
2218     return ;
2219   }
2220 }
2221
2222 JNIEXPORT void JNICALL
2223 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
2224   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2225 {
2226   guestfs_h *g = (guestfs_h *) (long) jg;
2227   int r;
2228   const char *path;
2229
2230   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2231   r = guestfs_mkdir (g, path);
2232   (*env)->ReleaseStringUTFChars (env, jpath, path);
2233   if (r == -1) {
2234     throw_exception (env, guestfs_last_error (g));
2235     return ;
2236   }
2237 }
2238
2239 JNIEXPORT void JNICALL
2240 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
2241   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2242 {
2243   guestfs_h *g = (guestfs_h *) (long) jg;
2244   int r;
2245   const char *path;
2246
2247   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2248   r = guestfs_mkdir_p (g, path);
2249   (*env)->ReleaseStringUTFChars (env, jpath, path);
2250   if (r == -1) {
2251     throw_exception (env, guestfs_last_error (g));
2252     return ;
2253   }
2254 }
2255
2256 JNIEXPORT void JNICALL
2257 Java_com_redhat_et_libguestfs_GuestFS__1chmod
2258   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
2259 {
2260   guestfs_h *g = (guestfs_h *) (long) jg;
2261   int r;
2262   int mode;
2263   const char *path;
2264
2265   mode = jmode;
2266   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2267   r = guestfs_chmod (g, mode, path);
2268   (*env)->ReleaseStringUTFChars (env, jpath, path);
2269   if (r == -1) {
2270     throw_exception (env, guestfs_last_error (g));
2271     return ;
2272   }
2273 }
2274
2275 JNIEXPORT void JNICALL
2276 Java_com_redhat_et_libguestfs_GuestFS__1chown
2277   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
2278 {
2279   guestfs_h *g = (guestfs_h *) (long) jg;
2280   int r;
2281   int owner;
2282   int group;
2283   const char *path;
2284
2285   owner = jowner;
2286   group = jgroup;
2287   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2288   r = guestfs_chown (g, owner, group, path);
2289   (*env)->ReleaseStringUTFChars (env, jpath, path);
2290   if (r == -1) {
2291     throw_exception (env, guestfs_last_error (g));
2292     return ;
2293   }
2294 }
2295
2296 JNIEXPORT jboolean JNICALL
2297 Java_com_redhat_et_libguestfs_GuestFS__1exists
2298   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2299 {
2300   guestfs_h *g = (guestfs_h *) (long) jg;
2301   int r;
2302   const char *path;
2303
2304   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2305   r = guestfs_exists (g, path);
2306   (*env)->ReleaseStringUTFChars (env, jpath, path);
2307   if (r == -1) {
2308     throw_exception (env, guestfs_last_error (g));
2309     return 0;
2310   }
2311   return (jboolean) r;
2312 }
2313
2314 JNIEXPORT jboolean JNICALL
2315 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
2316   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2317 {
2318   guestfs_h *g = (guestfs_h *) (long) jg;
2319   int r;
2320   const char *path;
2321
2322   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2323   r = guestfs_is_file (g, path);
2324   (*env)->ReleaseStringUTFChars (env, jpath, path);
2325   if (r == -1) {
2326     throw_exception (env, guestfs_last_error (g));
2327     return 0;
2328   }
2329   return (jboolean) r;
2330 }
2331
2332 JNIEXPORT jboolean JNICALL
2333 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
2334   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2335 {
2336   guestfs_h *g = (guestfs_h *) (long) jg;
2337   int r;
2338   const char *path;
2339
2340   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2341   r = guestfs_is_dir (g, path);
2342   (*env)->ReleaseStringUTFChars (env, jpath, path);
2343   if (r == -1) {
2344     throw_exception (env, guestfs_last_error (g));
2345     return 0;
2346   }
2347   return (jboolean) r;
2348 }
2349
2350 JNIEXPORT void JNICALL
2351 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
2352   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2353 {
2354   guestfs_h *g = (guestfs_h *) (long) jg;
2355   int r;
2356   const char *device;
2357
2358   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2359   r = guestfs_pvcreate (g, device);
2360   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2361   if (r == -1) {
2362     throw_exception (env, guestfs_last_error (g));
2363     return ;
2364   }
2365 }
2366
2367 JNIEXPORT void JNICALL
2368 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
2369   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
2370 {
2371   guestfs_h *g = (guestfs_h *) (long) jg;
2372   int r;
2373   const char *volgroup;
2374   int physvols_len;
2375   const char **physvols;
2376   int i;
2377
2378   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2379   physvols_len = (*env)->GetArrayLength (env, jphysvols);
2380   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
2381   for (i = 0; i < physvols_len; ++i) {
2382     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2383     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
2384   }
2385   physvols[physvols_len] = NULL;
2386   r = guestfs_vgcreate (g, volgroup, physvols);
2387   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2388   for (i = 0; i < physvols_len; ++i) {
2389     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2390     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
2391   }
2392   free (physvols);
2393   if (r == -1) {
2394     throw_exception (env, guestfs_last_error (g));
2395     return ;
2396   }
2397 }
2398
2399 JNIEXPORT void JNICALL
2400 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
2401   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
2402 {
2403   guestfs_h *g = (guestfs_h *) (long) jg;
2404   int r;
2405   const char *logvol;
2406   const char *volgroup;
2407   int mbytes;
2408
2409   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
2410   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2411   mbytes = jmbytes;
2412   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2413   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
2414   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2415   if (r == -1) {
2416     throw_exception (env, guestfs_last_error (g));
2417     return ;
2418   }
2419 }
2420
2421 JNIEXPORT void JNICALL
2422 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
2423   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2424 {
2425   guestfs_h *g = (guestfs_h *) (long) jg;
2426   int r;
2427   const char *fstype;
2428   const char *device;
2429
2430   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2431   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2432   r = guestfs_mkfs (g, fstype, device);
2433   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2434   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2435   if (r == -1) {
2436     throw_exception (env, guestfs_last_error (g));
2437     return ;
2438   }
2439 }
2440
2441 JNIEXPORT void JNICALL
2442 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
2443   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
2444 {
2445   guestfs_h *g = (guestfs_h *) (long) jg;
2446   int r;
2447   const char *device;
2448   int cyls;
2449   int heads;
2450   int sectors;
2451   int lines_len;
2452   const char **lines;
2453   int i;
2454
2455   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2456   cyls = jcyls;
2457   heads = jheads;
2458   sectors = jsectors;
2459   lines_len = (*env)->GetArrayLength (env, jlines);
2460   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
2461   for (i = 0; i < lines_len; ++i) {
2462     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2463     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
2464   }
2465   lines[lines_len] = NULL;
2466   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2467   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2468   for (i = 0; i < lines_len; ++i) {
2469     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2470     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
2471   }
2472   free (lines);
2473   if (r == -1) {
2474     throw_exception (env, guestfs_last_error (g));
2475     return ;
2476   }
2477 }
2478
2479 JNIEXPORT void JNICALL
2480 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
2481   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
2482 {
2483   guestfs_h *g = (guestfs_h *) (long) jg;
2484   int r;
2485   const char *path;
2486   const char *content;
2487   int size;
2488
2489   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2490   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
2491   size = jsize;
2492   r = guestfs_write_file (g, path, content, size);
2493   (*env)->ReleaseStringUTFChars (env, jpath, path);
2494   (*env)->ReleaseStringUTFChars (env, jcontent, content);
2495   if (r == -1) {
2496     throw_exception (env, guestfs_last_error (g));
2497     return ;
2498   }
2499 }
2500
2501 JNIEXPORT void JNICALL
2502 Java_com_redhat_et_libguestfs_GuestFS__1umount
2503   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
2504 {
2505   guestfs_h *g = (guestfs_h *) (long) jg;
2506   int r;
2507   const char *pathordevice;
2508
2509   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
2510   r = guestfs_umount (g, pathordevice);
2511   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
2512   if (r == -1) {
2513     throw_exception (env, guestfs_last_error (g));
2514     return ;
2515   }
2516 }
2517
2518 JNIEXPORT jobjectArray JNICALL
2519 Java_com_redhat_et_libguestfs_GuestFS__1mounts
2520   (JNIEnv *env, jobject obj, jlong jg)
2521 {
2522   guestfs_h *g = (guestfs_h *) (long) jg;
2523   jobjectArray jr;
2524   int r_len;
2525   jclass cl;
2526   jstring jstr;
2527   char **r;
2528   int i;
2529
2530   r = guestfs_mounts (g);
2531   if (r == NULL) {
2532     throw_exception (env, guestfs_last_error (g));
2533     return NULL;
2534   }
2535   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2536   cl = (*env)->FindClass (env, "java/lang/String");
2537   jstr = (*env)->NewStringUTF (env, "");
2538   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2539   for (i = 0; i < r_len; ++i) {
2540     jstr = (*env)->NewStringUTF (env, r[i]);
2541     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2542     free (r[i]);
2543   }
2544   free (r);
2545   return jr;
2546 }
2547
2548 JNIEXPORT void JNICALL
2549 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
2550   (JNIEnv *env, jobject obj, jlong jg)
2551 {
2552   guestfs_h *g = (guestfs_h *) (long) jg;
2553   int r;
2554
2555   r = guestfs_umount_all (g);
2556   if (r == -1) {
2557     throw_exception (env, guestfs_last_error (g));
2558     return ;
2559   }
2560 }
2561
2562 JNIEXPORT void JNICALL
2563 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
2564   (JNIEnv *env, jobject obj, jlong jg)
2565 {
2566   guestfs_h *g = (guestfs_h *) (long) jg;
2567   int r;
2568
2569   r = guestfs_lvm_remove_all (g);
2570   if (r == -1) {
2571     throw_exception (env, guestfs_last_error (g));
2572     return ;
2573   }
2574 }
2575
2576 JNIEXPORT jstring JNICALL
2577 Java_com_redhat_et_libguestfs_GuestFS__1file
2578   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2579 {
2580   guestfs_h *g = (guestfs_h *) (long) jg;
2581   jstring jr;
2582   char *r;
2583   const char *path;
2584
2585   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2586   r = guestfs_file (g, path);
2587   (*env)->ReleaseStringUTFChars (env, jpath, path);
2588   if (r == NULL) {
2589     throw_exception (env, guestfs_last_error (g));
2590     return NULL;
2591   }
2592   jr = (*env)->NewStringUTF (env, r);
2593   free (r);
2594   return jr;
2595 }
2596
2597 JNIEXPORT jstring JNICALL
2598 Java_com_redhat_et_libguestfs_GuestFS__1command
2599   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2600 {
2601   guestfs_h *g = (guestfs_h *) (long) jg;
2602   jstring jr;
2603   char *r;
2604   int arguments_len;
2605   const char **arguments;
2606   int i;
2607
2608   arguments_len = (*env)->GetArrayLength (env, jarguments);
2609   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2610   for (i = 0; i < arguments_len; ++i) {
2611     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2612     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2613   }
2614   arguments[arguments_len] = NULL;
2615   r = guestfs_command (g, arguments);
2616   for (i = 0; i < arguments_len; ++i) {
2617     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2618     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2619   }
2620   free (arguments);
2621   if (r == NULL) {
2622     throw_exception (env, guestfs_last_error (g));
2623     return NULL;
2624   }
2625   jr = (*env)->NewStringUTF (env, r);
2626   free (r);
2627   return jr;
2628 }
2629
2630 JNIEXPORT jobjectArray JNICALL
2631 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
2632   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2633 {
2634   guestfs_h *g = (guestfs_h *) (long) jg;
2635   jobjectArray jr;
2636   int r_len;
2637   jclass cl;
2638   jstring jstr;
2639   char **r;
2640   int arguments_len;
2641   const char **arguments;
2642   int i;
2643
2644   arguments_len = (*env)->GetArrayLength (env, jarguments);
2645   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2646   for (i = 0; i < arguments_len; ++i) {
2647     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2648     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2649   }
2650   arguments[arguments_len] = NULL;
2651   r = guestfs_command_lines (g, arguments);
2652   for (i = 0; i < arguments_len; ++i) {
2653     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2654     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2655   }
2656   free (arguments);
2657   if (r == NULL) {
2658     throw_exception (env, guestfs_last_error (g));
2659     return NULL;
2660   }
2661   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2662   cl = (*env)->FindClass (env, "java/lang/String");
2663   jstr = (*env)->NewStringUTF (env, "");
2664   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2665   for (i = 0; i < r_len; ++i) {
2666     jstr = (*env)->NewStringUTF (env, r[i]);
2667     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2668     free (r[i]);
2669   }
2670   free (r);
2671   return jr;
2672 }
2673
2674 JNIEXPORT jobject JNICALL
2675 Java_com_redhat_et_libguestfs_GuestFS__1stat
2676   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2677 {
2678   guestfs_h *g = (guestfs_h *) (long) jg;
2679   jobject jr;
2680   jclass cl;
2681   jfieldID fl;
2682   struct guestfs_stat *r;
2683   const char *path;
2684
2685   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2686   r = guestfs_stat (g, path);
2687   (*env)->ReleaseStringUTFChars (env, jpath, path);
2688   if (r == NULL) {
2689     throw_exception (env, guestfs_last_error (g));
2690     return NULL;
2691   }
2692   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2693   jr = (*env)->AllocObject (env, cl);
2694   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2695   (*env)->SetLongField (env, jr, fl, r->dev);
2696   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2697   (*env)->SetLongField (env, jr, fl, r->ino);
2698   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2699   (*env)->SetLongField (env, jr, fl, r->mode);
2700   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2701   (*env)->SetLongField (env, jr, fl, r->nlink);
2702   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2703   (*env)->SetLongField (env, jr, fl, r->uid);
2704   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2705   (*env)->SetLongField (env, jr, fl, r->gid);
2706   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2707   (*env)->SetLongField (env, jr, fl, r->rdev);
2708   fl = (*env)->GetFieldID (env, cl, "size", "J");
2709   (*env)->SetLongField (env, jr, fl, r->size);
2710   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2711   (*env)->SetLongField (env, jr, fl, r->blksize);
2712   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2713   (*env)->SetLongField (env, jr, fl, r->blocks);
2714   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2715   (*env)->SetLongField (env, jr, fl, r->atime);
2716   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2717   (*env)->SetLongField (env, jr, fl, r->mtime);
2718   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2719   (*env)->SetLongField (env, jr, fl, r->ctime);
2720   free (r);
2721   return jr;
2722 }
2723
2724 JNIEXPORT jobject JNICALL
2725 Java_com_redhat_et_libguestfs_GuestFS__1lstat
2726   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2727 {
2728   guestfs_h *g = (guestfs_h *) (long) jg;
2729   jobject jr;
2730   jclass cl;
2731   jfieldID fl;
2732   struct guestfs_stat *r;
2733   const char *path;
2734
2735   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2736   r = guestfs_lstat (g, path);
2737   (*env)->ReleaseStringUTFChars (env, jpath, path);
2738   if (r == NULL) {
2739     throw_exception (env, guestfs_last_error (g));
2740     return NULL;
2741   }
2742   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2743   jr = (*env)->AllocObject (env, cl);
2744   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2745   (*env)->SetLongField (env, jr, fl, r->dev);
2746   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2747   (*env)->SetLongField (env, jr, fl, r->ino);
2748   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2749   (*env)->SetLongField (env, jr, fl, r->mode);
2750   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2751   (*env)->SetLongField (env, jr, fl, r->nlink);
2752   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2753   (*env)->SetLongField (env, jr, fl, r->uid);
2754   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2755   (*env)->SetLongField (env, jr, fl, r->gid);
2756   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2757   (*env)->SetLongField (env, jr, fl, r->rdev);
2758   fl = (*env)->GetFieldID (env, cl, "size", "J");
2759   (*env)->SetLongField (env, jr, fl, r->size);
2760   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2761   (*env)->SetLongField (env, jr, fl, r->blksize);
2762   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2763   (*env)->SetLongField (env, jr, fl, r->blocks);
2764   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2765   (*env)->SetLongField (env, jr, fl, r->atime);
2766   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2767   (*env)->SetLongField (env, jr, fl, r->mtime);
2768   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2769   (*env)->SetLongField (env, jr, fl, r->ctime);
2770   free (r);
2771   return jr;
2772 }
2773
2774 JNIEXPORT jobject JNICALL
2775 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
2776   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2777 {
2778   guestfs_h *g = (guestfs_h *) (long) jg;
2779   jobject jr;
2780   jclass cl;
2781   jfieldID fl;
2782   struct guestfs_statvfs *r;
2783   const char *path;
2784
2785   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2786   r = guestfs_statvfs (g, path);
2787   (*env)->ReleaseStringUTFChars (env, jpath, path);
2788   if (r == NULL) {
2789     throw_exception (env, guestfs_last_error (g));
2790     return NULL;
2791   }
2792   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
2793   jr = (*env)->AllocObject (env, cl);
2794   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
2795   (*env)->SetLongField (env, jr, fl, r->bsize);
2796   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
2797   (*env)->SetLongField (env, jr, fl, r->frsize);
2798   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2799   (*env)->SetLongField (env, jr, fl, r->blocks);
2800   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
2801   (*env)->SetLongField (env, jr, fl, r->bfree);
2802   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
2803   (*env)->SetLongField (env, jr, fl, r->bavail);
2804   fl = (*env)->GetFieldID (env, cl, "files", "J");
2805   (*env)->SetLongField (env, jr, fl, r->files);
2806   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
2807   (*env)->SetLongField (env, jr, fl, r->ffree);
2808   fl = (*env)->GetFieldID (env, cl, "favail", "J");
2809   (*env)->SetLongField (env, jr, fl, r->favail);
2810   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
2811   (*env)->SetLongField (env, jr, fl, r->fsid);
2812   fl = (*env)->GetFieldID (env, cl, "flag", "J");
2813   (*env)->SetLongField (env, jr, fl, r->flag);
2814   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
2815   (*env)->SetLongField (env, jr, fl, r->namemax);
2816   free (r);
2817   return jr;
2818 }
2819
2820 JNIEXPORT jobject JNICALL
2821 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
2822   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2823 {
2824   guestfs_h *g = (guestfs_h *) (long) jg;
2825   char **r;
2826   const char *device;
2827
2828   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2829   r = guestfs_tune2fs_l (g, device);
2830   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2831   if (r == NULL) {
2832     throw_exception (env, guestfs_last_error (g));
2833     return NULL;
2834   }
2835   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
2836   return NULL;
2837 }
2838
2839 JNIEXPORT void JNICALL
2840 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
2841   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2842 {
2843   guestfs_h *g = (guestfs_h *) (long) jg;
2844   int r;
2845   const char *device;
2846
2847   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2848   r = guestfs_blockdev_setro (g, device);
2849   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2850   if (r == -1) {
2851     throw_exception (env, guestfs_last_error (g));
2852     return ;
2853   }
2854 }
2855
2856 JNIEXPORT void JNICALL
2857 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
2858   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2859 {
2860   guestfs_h *g = (guestfs_h *) (long) jg;
2861   int r;
2862   const char *device;
2863
2864   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2865   r = guestfs_blockdev_setrw (g, device);
2866   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2867   if (r == -1) {
2868     throw_exception (env, guestfs_last_error (g));
2869     return ;
2870   }
2871 }
2872
2873 JNIEXPORT jboolean JNICALL
2874 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
2875   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2876 {
2877   guestfs_h *g = (guestfs_h *) (long) jg;
2878   int r;
2879   const char *device;
2880
2881   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2882   r = guestfs_blockdev_getro (g, device);
2883   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2884   if (r == -1) {
2885     throw_exception (env, guestfs_last_error (g));
2886     return 0;
2887   }
2888   return (jboolean) r;
2889 }
2890
2891 JNIEXPORT jint JNICALL
2892 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
2893   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2894 {
2895   guestfs_h *g = (guestfs_h *) (long) jg;
2896   int r;
2897   const char *device;
2898
2899   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2900   r = guestfs_blockdev_getss (g, device);
2901   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2902   if (r == -1) {
2903     throw_exception (env, guestfs_last_error (g));
2904     return 0;
2905   }
2906   return (jint) r;
2907 }
2908
2909 JNIEXPORT jint JNICALL
2910 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
2911   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2912 {
2913   guestfs_h *g = (guestfs_h *) (long) jg;
2914   int r;
2915   const char *device;
2916
2917   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2918   r = guestfs_blockdev_getbsz (g, device);
2919   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2920   if (r == -1) {
2921     throw_exception (env, guestfs_last_error (g));
2922     return 0;
2923   }
2924   return (jint) r;
2925 }
2926
2927 JNIEXPORT void JNICALL
2928 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
2929   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
2930 {
2931   guestfs_h *g = (guestfs_h *) (long) jg;
2932   int r;
2933   const char *device;
2934   int blocksize;
2935
2936   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2937   blocksize = jblocksize;
2938   r = guestfs_blockdev_setbsz (g, device, blocksize);
2939   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2940   if (r == -1) {
2941     throw_exception (env, guestfs_last_error (g));
2942     return ;
2943   }
2944 }
2945
2946 JNIEXPORT jlong JNICALL
2947 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
2948   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2949 {
2950   guestfs_h *g = (guestfs_h *) (long) jg;
2951   int64_t r;
2952   const char *device;
2953
2954   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2955   r = guestfs_blockdev_getsz (g, device);
2956   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2957   if (r == -1) {
2958     throw_exception (env, guestfs_last_error (g));
2959     return 0;
2960   }
2961   return (jlong) r;
2962 }
2963
2964 JNIEXPORT jlong JNICALL
2965 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
2966   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2967 {
2968   guestfs_h *g = (guestfs_h *) (long) jg;
2969   int64_t r;
2970   const char *device;
2971
2972   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2973   r = guestfs_blockdev_getsize64 (g, device);
2974   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2975   if (r == -1) {
2976     throw_exception (env, guestfs_last_error (g));
2977     return 0;
2978   }
2979   return (jlong) r;
2980 }
2981
2982 JNIEXPORT void JNICALL
2983 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
2984   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2985 {
2986   guestfs_h *g = (guestfs_h *) (long) jg;
2987   int r;
2988   const char *device;
2989
2990   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2991   r = guestfs_blockdev_flushbufs (g, device);
2992   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2993   if (r == -1) {
2994     throw_exception (env, guestfs_last_error (g));
2995     return ;
2996   }
2997 }
2998
2999 JNIEXPORT void JNICALL
3000 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
3001   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3002 {
3003   guestfs_h *g = (guestfs_h *) (long) jg;
3004   int r;
3005   const char *device;
3006
3007   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3008   r = guestfs_blockdev_rereadpt (g, device);
3009   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3010   if (r == -1) {
3011     throw_exception (env, guestfs_last_error (g));
3012     return ;
3013   }
3014 }
3015
3016 JNIEXPORT void JNICALL
3017 Java_com_redhat_et_libguestfs_GuestFS__1upload
3018   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
3019 {
3020   guestfs_h *g = (guestfs_h *) (long) jg;
3021   int r;
3022   const char *filename;
3023   const char *remotefilename;
3024
3025   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3026   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3027   r = guestfs_upload (g, filename, remotefilename);
3028   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3029   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3030   if (r == -1) {
3031     throw_exception (env, guestfs_last_error (g));
3032     return ;
3033   }
3034 }
3035
3036 JNIEXPORT void JNICALL
3037 Java_com_redhat_et_libguestfs_GuestFS__1download
3038   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
3039 {
3040   guestfs_h *g = (guestfs_h *) (long) jg;
3041   int r;
3042   const char *remotefilename;
3043   const char *filename;
3044
3045   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3046   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3047   r = guestfs_download (g, remotefilename, filename);
3048   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3049   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3050   if (r == -1) {
3051     throw_exception (env, guestfs_last_error (g));
3052     return ;
3053   }
3054 }
3055
3056 JNIEXPORT jstring JNICALL
3057 Java_com_redhat_et_libguestfs_GuestFS__1checksum
3058   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
3059 {
3060   guestfs_h *g = (guestfs_h *) (long) jg;
3061   jstring jr;
3062   char *r;
3063   const char *csumtype;
3064   const char *path;
3065
3066   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
3067   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3068   r = guestfs_checksum (g, csumtype, path);
3069   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
3070   (*env)->ReleaseStringUTFChars (env, jpath, path);
3071   if (r == NULL) {
3072     throw_exception (env, guestfs_last_error (g));
3073     return NULL;
3074   }
3075   jr = (*env)->NewStringUTF (env, r);
3076   free (r);
3077   return jr;
3078 }
3079
3080 JNIEXPORT void JNICALL
3081 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
3082   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
3083 {
3084   guestfs_h *g = (guestfs_h *) (long) jg;
3085   int r;
3086   const char *tarfile;
3087   const char *directory;
3088
3089   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3090   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3091   r = guestfs_tar_in (g, tarfile, directory);
3092   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3093   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3094   if (r == -1) {
3095     throw_exception (env, guestfs_last_error (g));
3096     return ;
3097   }
3098 }
3099
3100 JNIEXPORT void JNICALL
3101 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
3102   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
3103 {
3104   guestfs_h *g = (guestfs_h *) (long) jg;
3105   int r;
3106   const char *directory;
3107   const char *tarfile;
3108
3109   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3110   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3111   r = guestfs_tar_out (g, directory, tarfile);
3112   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3113   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3114   if (r == -1) {
3115     throw_exception (env, guestfs_last_error (g));
3116     return ;
3117   }
3118 }
3119
3120 JNIEXPORT void JNICALL
3121 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
3122   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
3123 {
3124   guestfs_h *g = (guestfs_h *) (long) jg;
3125   int r;
3126   const char *tarball;
3127   const char *directory;
3128
3129   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3130   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3131   r = guestfs_tgz_in (g, tarball, directory);
3132   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3133   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3134   if (r == -1) {
3135     throw_exception (env, guestfs_last_error (g));
3136     return ;
3137   }
3138 }
3139
3140 JNIEXPORT void JNICALL
3141 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
3142   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
3143 {
3144   guestfs_h *g = (guestfs_h *) (long) jg;
3145   int r;
3146   const char *directory;
3147   const char *tarball;
3148
3149   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3150   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3151   r = guestfs_tgz_out (g, directory, tarball);
3152   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3153   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3154   if (r == -1) {
3155     throw_exception (env, guestfs_last_error (g));
3156     return ;
3157   }
3158 }
3159
3160 JNIEXPORT void JNICALL
3161 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
3162   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
3163 {
3164   guestfs_h *g = (guestfs_h *) (long) jg;
3165   int r;
3166   const char *device;
3167   const char *mountpoint;
3168
3169   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3170   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3171   r = guestfs_mount_ro (g, device, mountpoint);
3172   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3173   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3174   if (r == -1) {
3175     throw_exception (env, guestfs_last_error (g));
3176     return ;
3177   }
3178 }
3179
3180 JNIEXPORT void JNICALL
3181 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
3182   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
3183 {
3184   guestfs_h *g = (guestfs_h *) (long) jg;
3185   int r;
3186   const char *options;
3187   const char *device;
3188   const char *mountpoint;
3189
3190   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3191   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3192   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3193   r = guestfs_mount_options (g, options, device, mountpoint);
3194   (*env)->ReleaseStringUTFChars (env, joptions, options);
3195   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3196   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3197   if (r == -1) {
3198     throw_exception (env, guestfs_last_error (g));
3199     return ;
3200   }
3201 }
3202
3203 JNIEXPORT void JNICALL
3204 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
3205   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
3206 {
3207   guestfs_h *g = (guestfs_h *) (long) jg;
3208   int r;
3209   const char *options;
3210   const char *vfstype;
3211   const char *device;
3212   const char *mountpoint;
3213
3214   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3215   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
3216   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3217   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3218   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3219   (*env)->ReleaseStringUTFChars (env, joptions, options);
3220   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
3221   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3222   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3223   if (r == -1) {
3224     throw_exception (env, guestfs_last_error (g));
3225     return ;
3226   }
3227 }
3228
3229 JNIEXPORT jstring JNICALL
3230 Java_com_redhat_et_libguestfs_GuestFS__1debug
3231   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
3232 {
3233   guestfs_h *g = (guestfs_h *) (long) jg;
3234   jstring jr;
3235   char *r;
3236   const char *subcmd;
3237   int extraargs_len;
3238   const char **extraargs;
3239   int i;
3240
3241   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
3242   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
3243   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
3244   for (i = 0; i < extraargs_len; ++i) {
3245     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3246     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
3247   }
3248   extraargs[extraargs_len] = NULL;
3249   r = guestfs_debug (g, subcmd, extraargs);
3250   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
3251   for (i = 0; i < extraargs_len; ++i) {
3252     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3253     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
3254   }
3255   free (extraargs);
3256   if (r == NULL) {
3257     throw_exception (env, guestfs_last_error (g));
3258     return NULL;
3259   }
3260   jr = (*env)->NewStringUTF (env, r);
3261   free (r);
3262   return jr;
3263 }
3264
3265 JNIEXPORT void JNICALL
3266 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
3267   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3268 {
3269   guestfs_h *g = (guestfs_h *) (long) jg;
3270   int r;
3271   const char *device;
3272
3273   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3274   r = guestfs_lvremove (g, device);
3275   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3276   if (r == -1) {
3277     throw_exception (env, guestfs_last_error (g));
3278     return ;
3279   }
3280 }
3281
3282 JNIEXPORT void JNICALL
3283 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
3284   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
3285 {
3286   guestfs_h *g = (guestfs_h *) (long) jg;
3287   int r;
3288   const char *vgname;
3289
3290   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
3291   r = guestfs_vgremove (g, vgname);
3292   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
3293   if (r == -1) {
3294     throw_exception (env, guestfs_last_error (g));
3295     return ;
3296   }
3297 }
3298
3299 JNIEXPORT void JNICALL
3300 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
3301   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3302 {
3303   guestfs_h *g = (guestfs_h *) (long) jg;
3304   int r;
3305   const char *device;
3306
3307   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3308   r = guestfs_pvremove (g, device);
3309   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3310   if (r == -1) {
3311     throw_exception (env, guestfs_last_error (g));
3312     return ;
3313   }
3314 }
3315
3316 JNIEXPORT void JNICALL
3317 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
3318   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
3319 {
3320   guestfs_h *g = (guestfs_h *) (long) jg;
3321   int r;
3322   const char *device;
3323   const char *label;
3324
3325   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3326   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
3327   r = guestfs_set_e2label (g, device, label);
3328   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3329   (*env)->ReleaseStringUTFChars (env, jlabel, label);
3330   if (r == -1) {
3331     throw_exception (env, guestfs_last_error (g));
3332     return ;
3333   }
3334 }
3335
3336 JNIEXPORT jstring JNICALL
3337 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
3338   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3339 {
3340   guestfs_h *g = (guestfs_h *) (long) jg;
3341   jstring jr;
3342   char *r;
3343   const char *device;
3344
3345   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3346   r = guestfs_get_e2label (g, device);
3347   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3348   if (r == NULL) {
3349     throw_exception (env, guestfs_last_error (g));
3350     return NULL;
3351   }
3352   jr = (*env)->NewStringUTF (env, r);
3353   free (r);
3354   return jr;
3355 }
3356
3357 JNIEXPORT void JNICALL
3358 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
3359   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
3360 {
3361   guestfs_h *g = (guestfs_h *) (long) jg;
3362   int r;
3363   const char *device;
3364   const char *uuid;
3365
3366   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3367   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
3368   r = guestfs_set_e2uuid (g, device, uuid);
3369   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3370   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
3371   if (r == -1) {
3372     throw_exception (env, guestfs_last_error (g));
3373     return ;
3374   }
3375 }
3376
3377 JNIEXPORT jstring JNICALL
3378 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
3379   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3380 {
3381   guestfs_h *g = (guestfs_h *) (long) jg;
3382   jstring jr;
3383   char *r;
3384   const char *device;
3385
3386   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3387   r = guestfs_get_e2uuid (g, device);
3388   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3389   if (r == NULL) {
3390     throw_exception (env, guestfs_last_error (g));
3391     return NULL;
3392   }
3393   jr = (*env)->NewStringUTF (env, r);
3394   free (r);
3395   return jr;
3396 }
3397
3398 JNIEXPORT jint JNICALL
3399 Java_com_redhat_et_libguestfs_GuestFS__1fsck
3400   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
3401 {
3402   guestfs_h *g = (guestfs_h *) (long) jg;
3403   int r;
3404   const char *fstype;
3405   const char *device;
3406
3407   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
3408   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3409   r = guestfs_fsck (g, fstype, device);
3410   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
3411   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3412   if (r == -1) {
3413     throw_exception (env, guestfs_last_error (g));
3414     return 0;
3415   }
3416   return (jint) r;
3417 }
3418
3419 JNIEXPORT void JNICALL
3420 Java_com_redhat_et_libguestfs_GuestFS__1zero
3421   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3422 {
3423   guestfs_h *g = (guestfs_h *) (long) jg;
3424   int r;
3425   const char *device;
3426
3427   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3428   r = guestfs_zero (g, device);
3429   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3430   if (r == -1) {
3431     throw_exception (env, guestfs_last_error (g));
3432     return ;
3433   }
3434 }
3435
3436 JNIEXPORT void JNICALL
3437 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
3438   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
3439 {
3440   guestfs_h *g = (guestfs_h *) (long) jg;
3441   int r;
3442   const char *root;
3443   const char *device;
3444
3445   root = (*env)->GetStringUTFChars (env, jroot, NULL);
3446   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3447   r = guestfs_grub_install (g, root, device);
3448   (*env)->ReleaseStringUTFChars (env, jroot, root);
3449   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3450   if (r == -1) {
3451     throw_exception (env, guestfs_last_error (g));
3452     return ;
3453   }
3454 }
3455
3456 JNIEXPORT void JNICALL
3457 Java_com_redhat_et_libguestfs_GuestFS__1cp
3458   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3459 {
3460   guestfs_h *g = (guestfs_h *) (long) jg;
3461   int r;
3462   const char *src;
3463   const char *dest;
3464
3465   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3466   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3467   r = guestfs_cp (g, src, dest);
3468   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3469   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3470   if (r == -1) {
3471     throw_exception (env, guestfs_last_error (g));
3472     return ;
3473   }
3474 }
3475
3476 JNIEXPORT void JNICALL
3477 Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
3478   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3479 {
3480   guestfs_h *g = (guestfs_h *) (long) jg;
3481   int r;
3482   const char *src;
3483   const char *dest;
3484
3485   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3486   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3487   r = guestfs_cp_a (g, src, dest);
3488   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3489   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3490   if (r == -1) {
3491     throw_exception (env, guestfs_last_error (g));
3492     return ;
3493   }
3494 }
3495
3496 JNIEXPORT void JNICALL
3497 Java_com_redhat_et_libguestfs_GuestFS__1mv
3498   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3499 {
3500   guestfs_h *g = (guestfs_h *) (long) jg;
3501   int r;
3502   const char *src;
3503   const char *dest;
3504
3505   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3506   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3507   r = guestfs_mv (g, src, dest);
3508   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3509   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3510   if (r == -1) {
3511     throw_exception (env, guestfs_last_error (g));
3512     return ;
3513   }
3514 }
3515
3516 JNIEXPORT void JNICALL
3517 Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
3518   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
3519 {
3520   guestfs_h *g = (guestfs_h *) (long) jg;
3521   int r;
3522   int whattodrop;
3523
3524   whattodrop = jwhattodrop;
3525   r = guestfs_drop_caches (g, whattodrop);
3526   if (r == -1) {
3527     throw_exception (env, guestfs_last_error (g));
3528     return ;
3529   }
3530 }
3531
3532 JNIEXPORT jstring JNICALL
3533 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
3534   (JNIEnv *env, jobject obj, jlong jg)
3535 {
3536   guestfs_h *g = (guestfs_h *) (long) jg;
3537   jstring jr;
3538   char *r;
3539
3540   r = guestfs_dmesg (g);
3541   if (r == NULL) {
3542     throw_exception (env, guestfs_last_error (g));
3543     return NULL;
3544   }
3545   jr = (*env)->NewStringUTF (env, r);
3546   free (r);
3547   return jr;
3548 }
3549
3550 JNIEXPORT void JNICALL
3551 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
3552   (JNIEnv *env, jobject obj, jlong jg)
3553 {
3554   guestfs_h *g = (guestfs_h *) (long) jg;
3555   int r;
3556
3557   r = guestfs_ping_daemon (g);
3558   if (r == -1) {
3559     throw_exception (env, guestfs_last_error (g));
3560     return ;
3561   }
3562 }
3563
3564 JNIEXPORT jboolean JNICALL
3565 Java_com_redhat_et_libguestfs_GuestFS__1equal
3566   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
3567 {
3568   guestfs_h *g = (guestfs_h *) (long) jg;
3569   int r;
3570   const char *file1;
3571   const char *file2;
3572
3573   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
3574   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
3575   r = guestfs_equal (g, file1, file2);
3576   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
3577   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
3578   if (r == -1) {
3579     throw_exception (env, guestfs_last_error (g));
3580     return 0;
3581   }
3582   return (jboolean) r;
3583 }
3584
3585 JNIEXPORT jobjectArray JNICALL
3586 Java_com_redhat_et_libguestfs_GuestFS__1strings
3587   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3588 {
3589   guestfs_h *g = (guestfs_h *) (long) jg;
3590   jobjectArray jr;
3591   int r_len;
3592   jclass cl;
3593   jstring jstr;
3594   char **r;
3595   const char *path;
3596   int i;
3597
3598   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3599   r = guestfs_strings (g, path);
3600   (*env)->ReleaseStringUTFChars (env, jpath, path);
3601   if (r == NULL) {
3602     throw_exception (env, guestfs_last_error (g));
3603     return NULL;
3604   }
3605   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3606   cl = (*env)->FindClass (env, "java/lang/String");
3607   jstr = (*env)->NewStringUTF (env, "");
3608   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3609   for (i = 0; i < r_len; ++i) {
3610     jstr = (*env)->NewStringUTF (env, r[i]);
3611     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3612     free (r[i]);
3613   }
3614   free (r);
3615   return jr;
3616 }
3617
3618 JNIEXPORT jobjectArray JNICALL
3619 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
3620   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
3621 {
3622   guestfs_h *g = (guestfs_h *) (long) jg;
3623   jobjectArray jr;
3624   int r_len;
3625   jclass cl;
3626   jstring jstr;
3627   char **r;
3628   const char *encoding;
3629   const char *path;
3630   int i;
3631
3632   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
3633   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3634   r = guestfs_strings_e (g, encoding, path);
3635   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
3636   (*env)->ReleaseStringUTFChars (env, jpath, path);
3637   if (r == NULL) {
3638     throw_exception (env, guestfs_last_error (g));
3639     return NULL;
3640   }
3641   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3642   cl = (*env)->FindClass (env, "java/lang/String");
3643   jstr = (*env)->NewStringUTF (env, "");
3644   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3645   for (i = 0; i < r_len; ++i) {
3646     jstr = (*env)->NewStringUTF (env, r[i]);
3647     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3648     free (r[i]);
3649   }
3650   free (r);
3651   return jr;
3652 }
3653
3654 JNIEXPORT jstring JNICALL
3655 Java_com_redhat_et_libguestfs_GuestFS__1hexdump
3656   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3657 {
3658   guestfs_h *g = (guestfs_h *) (long) jg;
3659   jstring jr;
3660   char *r;
3661   const char *path;
3662
3663   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3664   r = guestfs_hexdump (g, path);
3665   (*env)->ReleaseStringUTFChars (env, jpath, path);
3666   if (r == NULL) {
3667     throw_exception (env, guestfs_last_error (g));
3668     return NULL;
3669   }
3670   jr = (*env)->NewStringUTF (env, r);
3671   free (r);
3672   return jr;
3673 }
3674
3675 JNIEXPORT void JNICALL
3676 Java_com_redhat_et_libguestfs_GuestFS__1zerofree
3677   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3678 {
3679   guestfs_h *g = (guestfs_h *) (long) jg;
3680   int r;
3681   const char *device;
3682
3683   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3684   r = guestfs_zerofree (g, device);
3685   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3686   if (r == -1) {
3687     throw_exception (env, guestfs_last_error (g));
3688     return ;
3689   }
3690 }
3691
3692 JNIEXPORT void JNICALL
3693 Java_com_redhat_et_libguestfs_GuestFS__1pvresize
3694   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3695 {
3696   guestfs_h *g = (guestfs_h *) (long) jg;
3697   int r;
3698   const char *device;
3699
3700   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3701   r = guestfs_pvresize (g, device);
3702   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3703   if (r == -1) {
3704     throw_exception (env, guestfs_last_error (g));
3705     return ;
3706   }
3707 }
3708
3709 JNIEXPORT void JNICALL
3710 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1N
3711   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jn, jint jcyls, jint jheads, jint jsectors, jstring jline)
3712 {
3713   guestfs_h *g = (guestfs_h *) (long) jg;
3714   int r;
3715   const char *device;
3716   int n;
3717   int cyls;
3718   int heads;
3719   int sectors;
3720   const char *line;
3721
3722   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3723   n = jn;
3724   cyls = jcyls;
3725   heads = jheads;
3726   sectors = jsectors;
3727   line = (*env)->GetStringUTFChars (env, jline, NULL);
3728   r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3729   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3730   (*env)->ReleaseStringUTFChars (env, jline, line);
3731   if (r == -1) {
3732     throw_exception (env, guestfs_last_error (g));
3733     return ;
3734   }
3735 }
3736
3737 JNIEXPORT jstring JNICALL
3738 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1l
3739   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3740 {
3741   guestfs_h *g = (guestfs_h *) (long) jg;
3742   jstring jr;
3743   char *r;
3744   const char *device;
3745
3746   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3747   r = guestfs_sfdisk_l (g, device);
3748   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3749   if (r == NULL) {
3750     throw_exception (env, guestfs_last_error (g));
3751     return NULL;
3752   }
3753   jr = (*env)->NewStringUTF (env, r);
3754   free (r);
3755   return jr;
3756 }
3757
3758 JNIEXPORT jstring JNICALL
3759 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1kernel_1geometry
3760   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3761 {
3762   guestfs_h *g = (guestfs_h *) (long) jg;
3763   jstring jr;
3764   char *r;
3765   const char *device;
3766
3767   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3768   r = guestfs_sfdisk_kernel_geometry (g, device);
3769   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3770   if (r == NULL) {
3771     throw_exception (env, guestfs_last_error (g));
3772     return NULL;
3773   }
3774   jr = (*env)->NewStringUTF (env, r);
3775   free (r);
3776   return jr;
3777 }
3778
3779 JNIEXPORT jstring JNICALL
3780 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1disk_1geometry
3781   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3782 {
3783   guestfs_h *g = (guestfs_h *) (long) jg;
3784   jstring jr;
3785   char *r;
3786   const char *device;
3787
3788   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3789   r = guestfs_sfdisk_disk_geometry (g, device);
3790   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3791   if (r == NULL) {
3792     throw_exception (env, guestfs_last_error (g));
3793     return NULL;
3794   }
3795   jr = (*env)->NewStringUTF (env, r);
3796   free (r);
3797   return jr;
3798 }
3799
3800 JNIEXPORT void JNICALL
3801 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate_1all
3802   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate)
3803 {
3804   guestfs_h *g = (guestfs_h *) (long) jg;
3805   int r;
3806   int activate;
3807
3808   activate = jactivate;
3809   r = guestfs_vg_activate_all (g, activate);
3810   if (r == -1) {
3811     throw_exception (env, guestfs_last_error (g));
3812     return ;
3813   }
3814 }
3815
3816 JNIEXPORT void JNICALL
3817 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate
3818   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate, jobjectArray jvolgroups)
3819 {
3820   guestfs_h *g = (guestfs_h *) (long) jg;
3821   int r;
3822   int activate;
3823   int volgroups_len;
3824   const char **volgroups;
3825   int i;
3826
3827   activate = jactivate;
3828   volgroups_len = (*env)->GetArrayLength (env, jvolgroups);
3829   volgroups = guestfs_safe_malloc (g, sizeof (char *) * (volgroups_len+1));
3830   for (i = 0; i < volgroups_len; ++i) {
3831     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3832     volgroups[i] = (*env)->GetStringUTFChars (env, o, NULL);
3833   }
3834   volgroups[volgroups_len] = NULL;
3835   r = guestfs_vg_activate (g, activate, volgroups);
3836   for (i = 0; i < volgroups_len; ++i) {
3837     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3838     (*env)->ReleaseStringUTFChars (env, o, volgroups[i]);
3839   }
3840   free (volgroups);
3841   if (r == -1) {
3842     throw_exception (env, guestfs_last_error (g));
3843     return ;
3844   }
3845 }
3846
3847 JNIEXPORT void JNICALL
3848 Java_com_redhat_et_libguestfs_GuestFS__1lvresize
3849   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jmbytes)
3850 {
3851   guestfs_h *g = (guestfs_h *) (long) jg;
3852   int r;
3853   const char *device;
3854   int mbytes;
3855
3856   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3857   mbytes = jmbytes;
3858   r = guestfs_lvresize (g, device, mbytes);
3859   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3860   if (r == -1) {
3861     throw_exception (env, guestfs_last_error (g));
3862     return ;
3863   }
3864 }
3865
3866 JNIEXPORT void JNICALL
3867 Java_com_redhat_et_libguestfs_GuestFS__1resize2fs
3868   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3869 {
3870   guestfs_h *g = (guestfs_h *) (long) jg;
3871   int r;
3872   const char *device;
3873
3874   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3875   r = guestfs_resize2fs (g, device);
3876   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3877   if (r == -1) {
3878     throw_exception (env, guestfs_last_error (g));
3879     return ;
3880   }
3881 }
3882
3883 JNIEXPORT jobjectArray JNICALL
3884 Java_com_redhat_et_libguestfs_GuestFS__1find
3885   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
3886 {
3887   guestfs_h *g = (guestfs_h *) (long) jg;
3888   jobjectArray jr;
3889   int r_len;
3890   jclass cl;
3891   jstring jstr;
3892   char **r;
3893   const char *directory;
3894   int i;
3895
3896   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3897   r = guestfs_find (g, directory);
3898   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3899   if (r == NULL) {
3900     throw_exception (env, guestfs_last_error (g));
3901     return NULL;
3902   }
3903   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3904   cl = (*env)->FindClass (env, "java/lang/String");
3905   jstr = (*env)->NewStringUTF (env, "");
3906   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3907   for (i = 0; i < r_len; ++i) {
3908     jstr = (*env)->NewStringUTF (env, r[i]);
3909     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3910     free (r[i]);
3911   }
3912   free (r);
3913   return jr;
3914 }
3915
3916 JNIEXPORT void JNICALL
3917 Java_com_redhat_et_libguestfs_GuestFS__1e2fsck_1f
3918   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3919 {
3920   guestfs_h *g = (guestfs_h *) (long) jg;
3921   int r;
3922   const char *device;
3923
3924   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3925   r = guestfs_e2fsck_f (g, device);
3926   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3927   if (r == -1) {
3928     throw_exception (env, guestfs_last_error (g));
3929     return ;
3930   }
3931 }
3932