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 = joptstr ? (*env)->GetStringUTFChars (env, joptstr, NULL) : 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   if (joptstr)
  96     (*env)->ReleaseStringUTFChars (env, joptstr, optstr);
  97   for (i = 0; i < strlist_len; ++i) {
  98     jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
  99     (*env)->ReleaseStringUTFChars (env, o, strlist[i]);
 100   }
 101   free (strlist);
 102   (*env)->ReleaseStringUTFChars (env, jfilein, filein);
 103   (*env)->ReleaseStringUTFChars (env, jfileout, fileout);
 104   if (r == -1) {
 105     throw_exception (env, guestfs_last_error (g));
 106     return ;
 107   }
 108 }
 109
 110 JNIEXPORT jint JNICALL
 111 Java_com_redhat_et_libguestfs_GuestFS__1test0rint
 112   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 113 {
 114   guestfs_h *g = (guestfs_h *) (long) jg;
 115   int r;
 116   const char *val;
 117
 118   val = (*env)->GetStringUTFChars (env, jval, NULL);
 119   r = guestfs_test0rint (g, val);
 120   (*env)->ReleaseStringUTFChars (env, jval, val);
 121   if (r == -1) {
 122     throw_exception (env, guestfs_last_error (g));
 123     return 0;
 124   }
 125   return (jint) r;
 126 }
 127
 128 JNIEXPORT jint JNICALL
 129 Java_com_redhat_et_libguestfs_GuestFS__1test0rinterr
 130   (JNIEnv *env, jobject obj, jlong jg)
 131 {
 132   guestfs_h *g = (guestfs_h *) (long) jg;
 133   int r;
 134
 135   r = guestfs_test0rinterr (g);
 136   if (r == -1) {
 137     throw_exception (env, guestfs_last_error (g));
 138     return 0;
 139   }
 140   return (jint) r;
 141 }
 142
 143 JNIEXPORT jlong JNICALL
 144 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64
 145   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 146 {
 147   guestfs_h *g = (guestfs_h *) (long) jg;
 148   int64_t r;
 149   const char *val;
 150
 151   val = (*env)->GetStringUTFChars (env, jval, NULL);
 152   r = guestfs_test0rint64 (g, val);
 153   (*env)->ReleaseStringUTFChars (env, jval, val);
 154   if (r == -1) {
 155     throw_exception (env, guestfs_last_error (g));
 156     return 0;
 157   }
 158   return (jlong) r;
 159 }
 160
 161 JNIEXPORT jlong JNICALL
 162 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64err
 163   (JNIEnv *env, jobject obj, jlong jg)
 164 {
 165   guestfs_h *g = (guestfs_h *) (long) jg;
 166   int64_t r;
 167
 168   r = guestfs_test0rint64err (g);
 169   if (r == -1) {
 170     throw_exception (env, guestfs_last_error (g));
 171     return 0;
 172   }
 173   return (jlong) r;
 174 }
 175
 176 JNIEXPORT jboolean JNICALL
 177 Java_com_redhat_et_libguestfs_GuestFS__1test0rbool
 178   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 179 {
 180   guestfs_h *g = (guestfs_h *) (long) jg;
 181   int r;
 182   const char *val;
 183
 184   val = (*env)->GetStringUTFChars (env, jval, NULL);
 185   r = guestfs_test0rbool (g, val);
 186   (*env)->ReleaseStringUTFChars (env, jval, val);
 187   if (r == -1) {
 188     throw_exception (env, guestfs_last_error (g));
 189     return 0;
 190   }
 191   return (jboolean) r;
 192 }
 193
 194 JNIEXPORT jboolean JNICALL
 195 Java_com_redhat_et_libguestfs_GuestFS__1test0rboolerr
 196   (JNIEnv *env, jobject obj, jlong jg)
 197 {
 198   guestfs_h *g = (guestfs_h *) (long) jg;
 199   int r;
 200
 201   r = guestfs_test0rboolerr (g);
 202   if (r == -1) {
 203     throw_exception (env, guestfs_last_error (g));
 204     return 0;
 205   }
 206   return (jboolean) r;
 207 }
 208
 209 JNIEXPORT jstring JNICALL
 210 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststring
 211   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 212 {
 213   guestfs_h *g = (guestfs_h *) (long) jg;
 214   const char *r;
 215   const char *val;
 216
 217   val = (*env)->GetStringUTFChars (env, jval, NULL);
 218   r = guestfs_test0rconststring (g, val);
 219   (*env)->ReleaseStringUTFChars (env, jval, val);
 220   if (r == NULL) {
 221     throw_exception (env, guestfs_last_error (g));
 222     return NULL;
 223   }
 224   return (*env)->NewStringUTF (env, r);
 225 }
 226
 227 JNIEXPORT jstring JNICALL
 228 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststringerr
 229   (JNIEnv *env, jobject obj, jlong jg)
 230 {
 231   guestfs_h *g = (guestfs_h *) (long) jg;
 232   const char *r;
 233
 234   r = guestfs_test0rconststringerr (g);
 235   if (r == NULL) {
 236     throw_exception (env, guestfs_last_error (g));
 237     return NULL;
 238   }
 239   return (*env)->NewStringUTF (env, r);
 240 }
 241
 242 JNIEXPORT jstring JNICALL
 243 Java_com_redhat_et_libguestfs_GuestFS__1test0rstring
 244   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 245 {
 246   guestfs_h *g = (guestfs_h *) (long) jg;
 247   jstring jr;
 248   char *r;
 249   const char *val;
 250
 251   val = (*env)->GetStringUTFChars (env, jval, NULL);
 252   r = guestfs_test0rstring (g, val);
 253   (*env)->ReleaseStringUTFChars (env, jval, val);
 254   if (r == NULL) {
 255     throw_exception (env, guestfs_last_error (g));
 256     return NULL;
 257   }
 258   jr = (*env)->NewStringUTF (env, r);
 259   free (r);
 260   return jr;
 261 }
 262
 263 JNIEXPORT jstring JNICALL
 264 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringerr
 265   (JNIEnv *env, jobject obj, jlong jg)
 266 {
 267   guestfs_h *g = (guestfs_h *) (long) jg;
 268   jstring jr;
 269   char *r;
 270
 271   r = guestfs_test0rstringerr (g);
 272   if (r == NULL) {
 273     throw_exception (env, guestfs_last_error (g));
 274     return NULL;
 275   }
 276   jr = (*env)->NewStringUTF (env, r);
 277   free (r);
 278   return jr;
 279 }
 280
 281 JNIEXPORT jobjectArray JNICALL
 282 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlist
 283   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 284 {
 285   guestfs_h *g = (guestfs_h *) (long) jg;
 286   jobjectArray jr;
 287   int r_len;
 288   jclass cl;
 289   jstring jstr;
 290   char **r;
 291   const char *val;
 292   int i;
 293
 294   val = (*env)->GetStringUTFChars (env, jval, NULL);
 295   r = guestfs_test0rstringlist (g, val);
 296   (*env)->ReleaseStringUTFChars (env, jval, val);
 297   if (r == NULL) {
 298     throw_exception (env, guestfs_last_error (g));
 299     return NULL;
 300   }
 301   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 302   cl = (*env)->FindClass (env, "java/lang/String");
 303   jstr = (*env)->NewStringUTF (env, "");
 304   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 305   for (i = 0; i < r_len; ++i) {
 306     jstr = (*env)->NewStringUTF (env, r[i]);
 307     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 308     free (r[i]);
 309   }
 310   free (r);
 311   return jr;
 312 }
 313
 314 JNIEXPORT jobjectArray JNICALL
 315 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlisterr
 316   (JNIEnv *env, jobject obj, jlong jg)
 317 {
 318   guestfs_h *g = (guestfs_h *) (long) jg;
 319   jobjectArray jr;
 320   int r_len;
 321   jclass cl;
 322   jstring jstr;
 323   char **r;
 324   int i;
 325
 326   r = guestfs_test0rstringlisterr (g);
 327   if (r == NULL) {
 328     throw_exception (env, guestfs_last_error (g));
 329     return NULL;
 330   }
 331   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 332   cl = (*env)->FindClass (env, "java/lang/String");
 333   jstr = (*env)->NewStringUTF (env, "");
 334   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 335   for (i = 0; i < r_len; ++i) {
 336     jstr = (*env)->NewStringUTF (env, r[i]);
 337     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 338     free (r[i]);
 339   }
 340   free (r);
 341   return jr;
 342 }
 343
 344 JNIEXPORT jobject JNICALL
 345 Java_com_redhat_et_libguestfs_GuestFS__1test0rintbool
 346   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 347 {
 348   guestfs_h *g = (guestfs_h *) (long) jg;
 349   jobject jr;
 350   jclass cl;
 351   jfieldID fl;
 352   struct guestfs_int_bool *r;
 353   const char *val;
 354
 355   val = (*env)->GetStringUTFChars (env, jval, NULL);
 356   r = guestfs_test0rintbool (g, val);
 357   (*env)->ReleaseStringUTFChars (env, jval, val);
 358   if (r == NULL) {
 359     throw_exception (env, guestfs_last_error (g));
 360     return NULL;
 361   }
 362   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 363   jr = (*env)->AllocObject (env, cl);
 364   fl = (*env)->GetFieldID (env, cl, "i", "I");
 365   (*env)->SetIntField (env, jr, fl, r->i);
 366   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 367   (*env)->SetBooleanField (env, jr, fl, r->b);
 368   guestfs_free_int_bool (r);
 369   return jr;
 370 }
 371
 372 JNIEXPORT jobject JNICALL
 373 Java_com_redhat_et_libguestfs_GuestFS__1test0rintboolerr
 374   (JNIEnv *env, jobject obj, jlong jg)
 375 {
 376   guestfs_h *g = (guestfs_h *) (long) jg;
 377   jobject jr;
 378   jclass cl;
 379   jfieldID fl;
 380   struct guestfs_int_bool *r;
 381
 382   r = guestfs_test0rintboolerr (g);
 383   if (r == NULL) {
 384     throw_exception (env, guestfs_last_error (g));
 385     return NULL;
 386   }
 387   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 388   jr = (*env)->AllocObject (env, cl);
 389   fl = (*env)->GetFieldID (env, cl, "i", "I");
 390   (*env)->SetIntField (env, jr, fl, r->i);
 391   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 392   (*env)->SetBooleanField (env, jr, fl, r->b);
 393   guestfs_free_int_bool (r);
 394   return jr;
 395 }
 396
 397 JNIEXPORT jobjectArray JNICALL
 398 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlist
 399   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 400 {
 401   guestfs_h *g = (guestfs_h *) (long) jg;
 402   jobjectArray jr;
 403   jclass cl;
 404   jfieldID fl;
 405   jobject jfl;
 406   struct guestfs_lvm_pv_list *r;
 407   const char *val;
 408   int i;
 409
 410   val = (*env)->GetStringUTFChars (env, jval, NULL);
 411   r = guestfs_test0rpvlist (g, val);
 412   (*env)->ReleaseStringUTFChars (env, jval, val);
 413   if (r == NULL) {
 414     throw_exception (env, guestfs_last_error (g));
 415     return NULL;
 416   }
 417   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 418   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 419   for (i = 0; i < r->len; ++i) {
 420     jfl = (*env)->AllocObject (env, cl);
 421     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 422     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 423     {
 424       char s[33];
 425       memcpy (s, r->val[i].pv_uuid, 32);
 426       s[32] = 0;
 427       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 428       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 429     }
 430     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 431     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 432     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 433     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 434     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 435     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 436     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 437     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 438     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 439     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 440     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 441     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 442     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 443     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 444     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 445     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 446     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 447     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 448     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 449     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 450     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 451     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 452     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 453     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 454     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 455   }
 456   guestfs_free_lvm_pv_list (r);
 457   return jr;
 458 }
 459
 460 JNIEXPORT jobjectArray JNICALL
 461 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlisterr
 462   (JNIEnv *env, jobject obj, jlong jg)
 463 {
 464   guestfs_h *g = (guestfs_h *) (long) jg;
 465   jobjectArray jr;
 466   jclass cl;
 467   jfieldID fl;
 468   jobject jfl;
 469   struct guestfs_lvm_pv_list *r;
 470   int i;
 471
 472   r = guestfs_test0rpvlisterr (g);
 473   if (r == NULL) {
 474     throw_exception (env, guestfs_last_error (g));
 475     return NULL;
 476   }
 477   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 478   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 479   for (i = 0; i < r->len; ++i) {
 480     jfl = (*env)->AllocObject (env, cl);
 481     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 482     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 483     {
 484       char s[33];
 485       memcpy (s, r->val[i].pv_uuid, 32);
 486       s[32] = 0;
 487       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 488       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 489     }
 490     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 491     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 492     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 493     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 494     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 495     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 496     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 497     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 498     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 499     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 500     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 501     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 502     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 503     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 504     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 505     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 506     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 507     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 508     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 509     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 510     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 511     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 512     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 513     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 514     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 515   }
 516   guestfs_free_lvm_pv_list (r);
 517   return jr;
 518 }
 519
 520 JNIEXPORT jobjectArray JNICALL
 521 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglist
 522   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 523 {
 524   guestfs_h *g = (guestfs_h *) (long) jg;
 525   jobjectArray jr;
 526   jclass cl;
 527   jfieldID fl;
 528   jobject jfl;
 529   struct guestfs_lvm_vg_list *r;
 530   const char *val;
 531   int i;
 532
 533   val = (*env)->GetStringUTFChars (env, jval, NULL);
 534   r = guestfs_test0rvglist (g, val);
 535   (*env)->ReleaseStringUTFChars (env, jval, val);
 536   if (r == NULL) {
 537     throw_exception (env, guestfs_last_error (g));
 538     return NULL;
 539   }
 540   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 541   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 542   for (i = 0; i < r->len; ++i) {
 543     jfl = (*env)->AllocObject (env, cl);
 544     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 545     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 546     {
 547       char s[33];
 548       memcpy (s, r->val[i].vg_uuid, 32);
 549       s[32] = 0;
 550       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 551       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 552     }
 553     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 554     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 555     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 556     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 557     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 558     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 559     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 560     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 561     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 562     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 563     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 564     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 565     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 566     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 567     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 568     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 569     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 570     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 571     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 572     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 573     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 574     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 575     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 576     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 577     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 578     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 579     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 580     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 581     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 582     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 583     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 584     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 585     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 586     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 587     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 588   }
 589   guestfs_free_lvm_vg_list (r);
 590   return jr;
 591 }
 592
 593 JNIEXPORT jobjectArray JNICALL
 594 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglisterr
 595   (JNIEnv *env, jobject obj, jlong jg)
 596 {
 597   guestfs_h *g = (guestfs_h *) (long) jg;
 598   jobjectArray jr;
 599   jclass cl;
 600   jfieldID fl;
 601   jobject jfl;
 602   struct guestfs_lvm_vg_list *r;
 603   int i;
 604
 605   r = guestfs_test0rvglisterr (g);
 606   if (r == NULL) {
 607     throw_exception (env, guestfs_last_error (g));
 608     return NULL;
 609   }
 610   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 611   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 612   for (i = 0; i < r->len; ++i) {
 613     jfl = (*env)->AllocObject (env, cl);
 614     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 615     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 616     {
 617       char s[33];
 618       memcpy (s, r->val[i].vg_uuid, 32);
 619       s[32] = 0;
 620       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 621       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 622     }
 623     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 624     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 625     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 626     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 627     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 628     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 629     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 630     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 631     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 632     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 633     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 634     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 635     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 636     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 637     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 638     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 639     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 640     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 641     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 642     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 643     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 644     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 645     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 646     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 647     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 648     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 649     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 650     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 651     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 652     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 653     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 654     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 655     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 656     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 657     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 658   }
 659   guestfs_free_lvm_vg_list (r);
 660   return jr;
 661 }
 662
 663 JNIEXPORT jobjectArray JNICALL
 664 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlist
 665   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 666 {
 667   guestfs_h *g = (guestfs_h *) (long) jg;
 668   jobjectArray jr;
 669   jclass cl;
 670   jfieldID fl;
 671   jobject jfl;
 672   struct guestfs_lvm_lv_list *r;
 673   const char *val;
 674   int i;
 675
 676   val = (*env)->GetStringUTFChars (env, jval, NULL);
 677   r = guestfs_test0rlvlist (g, val);
 678   (*env)->ReleaseStringUTFChars (env, jval, val);
 679   if (r == NULL) {
 680     throw_exception (env, guestfs_last_error (g));
 681     return NULL;
 682   }
 683   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
 684   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 685   for (i = 0; i < r->len; ++i) {
 686     jfl = (*env)->AllocObject (env, cl);
 687     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 688     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 689     {
 690       char s[33];
 691       memcpy (s, r->val[i].lv_uuid, 32);
 692       s[32] = 0;
 693       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 694       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 695     }
 696     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 697     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 698     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 699     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 700     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 701     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 702     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 703     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 704     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 705     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 706     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 707     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 708     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 709     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 710     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 711     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 712     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 713     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 714     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 715     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 716     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 717     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 718     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 719     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 720     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 721     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 722     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 723     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 724     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 725   }
 726   guestfs_free_lvm_lv_list (r);
 727   return jr;
 728 }
 729
 730 JNIEXPORT jobjectArray JNICALL
 731 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlisterr
 732   (JNIEnv *env, jobject obj, jlong jg)
 733 {
 734   guestfs_h *g = (guestfs_h *) (long) jg;
 735   jobjectArray jr;
 736   jclass cl;
 737   jfieldID fl;
 738   jobject jfl;
 739   struct guestfs_lvm_lv_list *r;
 740   int i;
 741
 742   r = guestfs_test0rlvlisterr (g);
 743   if (r == NULL) {
 744     throw_exception (env, guestfs_last_error (g));
 745     return NULL;
 746   }
 747   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
 748   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 749   for (i = 0; i < r->len; ++i) {
 750     jfl = (*env)->AllocObject (env, cl);
 751     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 753     {
 754       char s[33];
 755       memcpy (s, r->val[i].lv_uuid, 32);
 756       s[32] = 0;
 757       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 758       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 759     }
 760     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 761     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 762     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 763     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 764     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 765     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 766     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 767     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 768     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 769     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 770     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 771     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 772     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 773     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 774     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 775     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 776     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 777     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 778     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 779     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 780     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 781     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 782     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 783     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 784     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 785     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 786     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 787     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 788     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 789   }
 790   guestfs_free_lvm_lv_list (r);
 791   return jr;
 792 }
 793
 794 JNIEXPORT jobject JNICALL
 795 Java_com_redhat_et_libguestfs_GuestFS__1test0rstat
 796   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 797 {
 798   guestfs_h *g = (guestfs_h *) (long) jg;
 799   jobject jr;
 800   jclass cl;
 801   jfieldID fl;
 802   struct guestfs_stat *r;
 803   const char *val;
 804
 805   val = (*env)->GetStringUTFChars (env, jval, NULL);
 806   r = guestfs_test0rstat (g, val);
 807   (*env)->ReleaseStringUTFChars (env, jval, val);
 808   if (r == NULL) {
 809     throw_exception (env, guestfs_last_error (g));
 810     return NULL;
 811   }
 812   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
 813   jr = (*env)->AllocObject (env, cl);
 814   fl = (*env)->GetFieldID (env, cl, "dev", "J");
 815   (*env)->SetLongField (env, jr, fl, r->dev);
 816   fl = (*env)->GetFieldID (env, cl, "ino", "J");
 817   (*env)->SetLongField (env, jr, fl, r->ino);
 818   fl = (*env)->GetFieldID (env, cl, "mode", "J");
 819   (*env)->SetLongField (env, jr, fl, r->mode);
 820   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
 821   (*env)->SetLongField (env, jr, fl, r->nlink);
 822   fl = (*env)->GetFieldID (env, cl, "uid", "J");
 823   (*env)->SetLongField (env, jr, fl, r->uid);
 824   fl = (*env)->GetFieldID (env, cl, "gid", "J");
 825   (*env)->SetLongField (env, jr, fl, r->gid);
 826   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
 827   (*env)->SetLongField (env, jr, fl, r->rdev);
 828   fl = (*env)->GetFieldID (env, cl, "size", "J");
 829   (*env)->SetLongField (env, jr, fl, r->size);
 830   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
 831   (*env)->SetLongField (env, jr, fl, r->blksize);
 832   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 833   (*env)->SetLongField (env, jr, fl, r->blocks);
 834   fl = (*env)->GetFieldID (env, cl, "atime", "J");
 835   (*env)->SetLongField (env, jr, fl, r->atime);
 836   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
 837   (*env)->SetLongField (env, jr, fl, r->mtime);
 838   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
 839   (*env)->SetLongField (env, jr, fl, r->ctime);
 840   free (r);
 841   return jr;
 842 }
 843
 844 JNIEXPORT jobject JNICALL
 845 Java_com_redhat_et_libguestfs_GuestFS__1test0rstaterr
 846   (JNIEnv *env, jobject obj, jlong jg)
 847 {
 848   guestfs_h *g = (guestfs_h *) (long) jg;
 849   jobject jr;
 850   jclass cl;
 851   jfieldID fl;
 852   struct guestfs_stat *r;
 853
 854   r = guestfs_test0rstaterr (g);
 855   if (r == NULL) {
 856     throw_exception (env, guestfs_last_error (g));
 857     return NULL;
 858   }
 859   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
 860   jr = (*env)->AllocObject (env, cl);
 861   fl = (*env)->GetFieldID (env, cl, "dev", "J");
 862   (*env)->SetLongField (env, jr, fl, r->dev);
 863   fl = (*env)->GetFieldID (env, cl, "ino", "J");
 864   (*env)->SetLongField (env, jr, fl, r->ino);
 865   fl = (*env)->GetFieldID (env, cl, "mode", "J");
 866   (*env)->SetLongField (env, jr, fl, r->mode);
 867   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
 868   (*env)->SetLongField (env, jr, fl, r->nlink);
 869   fl = (*env)->GetFieldID (env, cl, "uid", "J");
 870   (*env)->SetLongField (env, jr, fl, r->uid);
 871   fl = (*env)->GetFieldID (env, cl, "gid", "J");
 872   (*env)->SetLongField (env, jr, fl, r->gid);
 873   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
 874   (*env)->SetLongField (env, jr, fl, r->rdev);
 875   fl = (*env)->GetFieldID (env, cl, "size", "J");
 876   (*env)->SetLongField (env, jr, fl, r->size);
 877   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
 878   (*env)->SetLongField (env, jr, fl, r->blksize);
 879   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 880   (*env)->SetLongField (env, jr, fl, r->blocks);
 881   fl = (*env)->GetFieldID (env, cl, "atime", "J");
 882   (*env)->SetLongField (env, jr, fl, r->atime);
 883   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
 884   (*env)->SetLongField (env, jr, fl, r->mtime);
 885   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
 886   (*env)->SetLongField (env, jr, fl, r->ctime);
 887   free (r);
 888   return jr;
 889 }
 890
 891 JNIEXPORT jobject JNICALL
 892 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfs
 893   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 894 {
 895   guestfs_h *g = (guestfs_h *) (long) jg;
 896   jobject jr;
 897   jclass cl;
 898   jfieldID fl;
 899   struct guestfs_statvfs *r;
 900   const char *val;
 901
 902   val = (*env)->GetStringUTFChars (env, jval, NULL);
 903   r = guestfs_test0rstatvfs (g, val);
 904   (*env)->ReleaseStringUTFChars (env, jval, val);
 905   if (r == NULL) {
 906     throw_exception (env, guestfs_last_error (g));
 907     return NULL;
 908   }
 909   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
 910   jr = (*env)->AllocObject (env, cl);
 911   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
 912   (*env)->SetLongField (env, jr, fl, r->bsize);
 913   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
 914   (*env)->SetLongField (env, jr, fl, r->frsize);
 915   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 916   (*env)->SetLongField (env, jr, fl, r->blocks);
 917   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
 918   (*env)->SetLongField (env, jr, fl, r->bfree);
 919   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
 920   (*env)->SetLongField (env, jr, fl, r->bavail);
 921   fl = (*env)->GetFieldID (env, cl, "files", "J");
 922   (*env)->SetLongField (env, jr, fl, r->files);
 923   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
 924   (*env)->SetLongField (env, jr, fl, r->ffree);
 925   fl = (*env)->GetFieldID (env, cl, "favail", "J");
 926   (*env)->SetLongField (env, jr, fl, r->favail);
 927   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
 928   (*env)->SetLongField (env, jr, fl, r->fsid);
 929   fl = (*env)->GetFieldID (env, cl, "flag", "J");
 930   (*env)->SetLongField (env, jr, fl, r->flag);
 931   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
 932   (*env)->SetLongField (env, jr, fl, r->namemax);
 933   free (r);
 934   return jr;
 935 }
 936
 937 JNIEXPORT jobject JNICALL
 938 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfserr
 939   (JNIEnv *env, jobject obj, jlong jg)
 940 {
 941   guestfs_h *g = (guestfs_h *) (long) jg;
 942   jobject jr;
 943   jclass cl;
 944   jfieldID fl;
 945   struct guestfs_statvfs *r;
 946
 947   r = guestfs_test0rstatvfserr (g);
 948   if (r == NULL) {
 949     throw_exception (env, guestfs_last_error (g));
 950     return NULL;
 951   }
 952   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
 953   jr = (*env)->AllocObject (env, cl);
 954   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
 955   (*env)->SetLongField (env, jr, fl, r->bsize);
 956   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
 957   (*env)->SetLongField (env, jr, fl, r->frsize);
 958   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
 959   (*env)->SetLongField (env, jr, fl, r->blocks);
 960   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
 961   (*env)->SetLongField (env, jr, fl, r->bfree);
 962   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
 963   (*env)->SetLongField (env, jr, fl, r->bavail);
 964   fl = (*env)->GetFieldID (env, cl, "files", "J");
 965   (*env)->SetLongField (env, jr, fl, r->files);
 966   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
 967   (*env)->SetLongField (env, jr, fl, r->ffree);
 968   fl = (*env)->GetFieldID (env, cl, "favail", "J");
 969   (*env)->SetLongField (env, jr, fl, r->favail);
 970   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
 971   (*env)->SetLongField (env, jr, fl, r->fsid);
 972   fl = (*env)->GetFieldID (env, cl, "flag", "J");
 973   (*env)->SetLongField (env, jr, fl, r->flag);
 974   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
 975   (*env)->SetLongField (env, jr, fl, r->namemax);
 976   free (r);
 977   return jr;
 978 }
 979
 980 JNIEXPORT jobject JNICALL
 981 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtable
 982   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
 983 {
 984   guestfs_h *g = (guestfs_h *) (long) jg;
 985   char **r;
 986   const char *val;
 987
 988   val = (*env)->GetStringUTFChars (env, jval, NULL);
 989   r = guestfs_test0rhashtable (g, val);
 990   (*env)->ReleaseStringUTFChars (env, jval, val);
 991   if (r == NULL) {
 992     throw_exception (env, guestfs_last_error (g));
 993     return NULL;
 994   }
 995   throw_exception (env, "test0rhashtable: internal error: please let us know how to make a Java HashMap from JNI bindings!");
 996   return NULL;
 997 }
 998
 999 JNIEXPORT jobject JNICALL
1000 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtableerr
1001   (JNIEnv *env, jobject obj, jlong jg)
1002 {
1003   guestfs_h *g = (guestfs_h *) (long) jg;
1004   char **r;
1005
1006   r = guestfs_test0rhashtableerr (g);
1007   if (r == NULL) {
1008     throw_exception (env, guestfs_last_error (g));
1009     return NULL;
1010   }
1011   throw_exception (env, "test0rhashtableerr: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1012   return NULL;
1013 }
1014
1015 JNIEXPORT void JNICALL
1016 Java_com_redhat_et_libguestfs_GuestFS__1launch
1017   (JNIEnv *env, jobject obj, jlong jg)
1018 {
1019   guestfs_h *g = (guestfs_h *) (long) jg;
1020   int r;
1021
1022   r = guestfs_launch (g);
1023   if (r == -1) {
1024     throw_exception (env, guestfs_last_error (g));
1025     return ;
1026   }
1027 }
1028
1029 JNIEXPORT void JNICALL
1030 Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
1031   (JNIEnv *env, jobject obj, jlong jg)
1032 {
1033   guestfs_h *g = (guestfs_h *) (long) jg;
1034   int r;
1035
1036   r = guestfs_wait_ready (g);
1037   if (r == -1) {
1038     throw_exception (env, guestfs_last_error (g));
1039     return ;
1040   }
1041 }
1042
1043 JNIEXPORT void JNICALL
1044 Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
1045   (JNIEnv *env, jobject obj, jlong jg)
1046 {
1047   guestfs_h *g = (guestfs_h *) (long) jg;
1048   int r;
1049
1050   r = guestfs_kill_subprocess (g);
1051   if (r == -1) {
1052     throw_exception (env, guestfs_last_error (g));
1053     return ;
1054   }
1055 }
1056
1057 JNIEXPORT void JNICALL
1058 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
1059   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1060 {
1061   guestfs_h *g = (guestfs_h *) (long) jg;
1062   int r;
1063   const char *filename;
1064
1065   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1066   r = guestfs_add_drive (g, filename);
1067   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1068   if (r == -1) {
1069     throw_exception (env, guestfs_last_error (g));
1070     return ;
1071   }
1072 }
1073
1074 JNIEXPORT void JNICALL
1075 Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
1076   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1077 {
1078   guestfs_h *g = (guestfs_h *) (long) jg;
1079   int r;
1080   const char *filename;
1081
1082   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1083   r = guestfs_add_cdrom (g, filename);
1084   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1085   if (r == -1) {
1086     throw_exception (env, guestfs_last_error (g));
1087     return ;
1088   }
1089 }
1090
1091 JNIEXPORT void JNICALL
1092 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive_1ro
1093   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1094 {
1095   guestfs_h *g = (guestfs_h *) (long) jg;
1096   int r;
1097   const char *filename;
1098
1099   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1100   r = guestfs_add_drive_ro (g, filename);
1101   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1102   if (r == -1) {
1103     throw_exception (env, guestfs_last_error (g));
1104     return ;
1105   }
1106 }
1107
1108 JNIEXPORT void JNICALL
1109 Java_com_redhat_et_libguestfs_GuestFS__1config
1110   (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
1111 {
1112   guestfs_h *g = (guestfs_h *) (long) jg;
1113   int r;
1114   const char *qemuparam;
1115   const char *qemuvalue;
1116
1117   qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
1118   qemuvalue = jqemuvalue ? (*env)->GetStringUTFChars (env, jqemuvalue, NULL) : NULL;
1119   r = guestfs_config (g, qemuparam, qemuvalue);
1120   (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
1121   if (jqemuvalue)
1122     (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
1123   if (r == -1) {
1124     throw_exception (env, guestfs_last_error (g));
1125     return ;
1126   }
1127 }
1128
1129 JNIEXPORT void JNICALL
1130 Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
1131   (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
1132 {
1133   guestfs_h *g = (guestfs_h *) (long) jg;
1134   int r;
1135   const char *qemu;
1136
1137   qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
1138   r = guestfs_set_qemu (g, qemu);
1139   (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
1140   if (r == -1) {
1141     throw_exception (env, guestfs_last_error (g));
1142     return ;
1143   }
1144 }
1145
1146 JNIEXPORT jstring JNICALL
1147 Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
1148   (JNIEnv *env, jobject obj, jlong jg)
1149 {
1150   guestfs_h *g = (guestfs_h *) (long) jg;
1151   const char *r;
1152
1153   r = guestfs_get_qemu (g);
1154   if (r == NULL) {
1155     throw_exception (env, guestfs_last_error (g));
1156     return NULL;
1157   }
1158   return (*env)->NewStringUTF (env, r);
1159 }
1160
1161 JNIEXPORT void JNICALL
1162 Java_com_redhat_et_libguestfs_GuestFS__1set_1path
1163   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1164 {
1165   guestfs_h *g = (guestfs_h *) (long) jg;
1166   int r;
1167   const char *path;
1168
1169   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1170   r = guestfs_set_path (g, path);
1171   (*env)->ReleaseStringUTFChars (env, jpath, path);
1172   if (r == -1) {
1173     throw_exception (env, guestfs_last_error (g));
1174     return ;
1175   }
1176 }
1177
1178 JNIEXPORT jstring JNICALL
1179 Java_com_redhat_et_libguestfs_GuestFS__1get_1path
1180   (JNIEnv *env, jobject obj, jlong jg)
1181 {
1182   guestfs_h *g = (guestfs_h *) (long) jg;
1183   const char *r;
1184
1185   r = guestfs_get_path (g);
1186   if (r == NULL) {
1187     throw_exception (env, guestfs_last_error (g));
1188     return NULL;
1189   }
1190   return (*env)->NewStringUTF (env, r);
1191 }
1192
1193 JNIEXPORT void JNICALL
1194 Java_com_redhat_et_libguestfs_GuestFS__1set_1append
1195   (JNIEnv *env, jobject obj, jlong jg, jstring jappend)
1196 {
1197   guestfs_h *g = (guestfs_h *) (long) jg;
1198   int r;
1199   const char *append;
1200
1201   append = (*env)->GetStringUTFChars (env, jappend, NULL);
1202   r = guestfs_set_append (g, append);
1203   (*env)->ReleaseStringUTFChars (env, jappend, append);
1204   if (r == -1) {
1205     throw_exception (env, guestfs_last_error (g));
1206     return ;
1207   }
1208 }
1209
1210 JNIEXPORT jstring JNICALL
1211 Java_com_redhat_et_libguestfs_GuestFS__1get_1append
1212   (JNIEnv *env, jobject obj, jlong jg)
1213 {
1214   guestfs_h *g = (guestfs_h *) (long) jg;
1215   const char *r;
1216
1217   r = guestfs_get_append (g);
1218   if (r == NULL) {
1219     throw_exception (env, guestfs_last_error (g));
1220     return NULL;
1221   }
1222   return (*env)->NewStringUTF (env, r);
1223 }
1224
1225 JNIEXPORT void JNICALL
1226 Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
1227   (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
1228 {
1229   guestfs_h *g = (guestfs_h *) (long) jg;
1230   int r;
1231   int autosync;
1232
1233   autosync = jautosync;
1234   r = guestfs_set_autosync (g, autosync);
1235   if (r == -1) {
1236     throw_exception (env, guestfs_last_error (g));
1237     return ;
1238   }
1239 }
1240
1241 JNIEXPORT jboolean JNICALL
1242 Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
1243   (JNIEnv *env, jobject obj, jlong jg)
1244 {
1245   guestfs_h *g = (guestfs_h *) (long) jg;
1246   int r;
1247
1248   r = guestfs_get_autosync (g);
1249   if (r == -1) {
1250     throw_exception (env, guestfs_last_error (g));
1251     return 0;
1252   }
1253   return (jboolean) r;
1254 }
1255
1256 JNIEXPORT void JNICALL
1257 Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
1258   (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
1259 {
1260   guestfs_h *g = (guestfs_h *) (long) jg;
1261   int r;
1262   int verbose;
1263
1264   verbose = jverbose;
1265   r = guestfs_set_verbose (g, verbose);
1266   if (r == -1) {
1267     throw_exception (env, guestfs_last_error (g));
1268     return ;
1269   }
1270 }
1271
1272 JNIEXPORT jboolean JNICALL
1273 Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
1274   (JNIEnv *env, jobject obj, jlong jg)
1275 {
1276   guestfs_h *g = (guestfs_h *) (long) jg;
1277   int r;
1278
1279   r = guestfs_get_verbose (g);
1280   if (r == -1) {
1281     throw_exception (env, guestfs_last_error (g));
1282     return 0;
1283   }
1284   return (jboolean) r;
1285 }
1286
1287 JNIEXPORT jboolean JNICALL
1288 Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
1289   (JNIEnv *env, jobject obj, jlong jg)
1290 {
1291   guestfs_h *g = (guestfs_h *) (long) jg;
1292   int r;
1293
1294   r = guestfs_is_ready (g);
1295   if (r == -1) {
1296     throw_exception (env, guestfs_last_error (g));
1297     return 0;
1298   }
1299   return (jboolean) r;
1300 }
1301
1302 JNIEXPORT jboolean JNICALL
1303 Java_com_redhat_et_libguestfs_GuestFS__1is_1config
1304   (JNIEnv *env, jobject obj, jlong jg)
1305 {
1306   guestfs_h *g = (guestfs_h *) (long) jg;
1307   int r;
1308
1309   r = guestfs_is_config (g);
1310   if (r == -1) {
1311     throw_exception (env, guestfs_last_error (g));
1312     return 0;
1313   }
1314   return (jboolean) r;
1315 }
1316
1317 JNIEXPORT jboolean JNICALL
1318 Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
1319   (JNIEnv *env, jobject obj, jlong jg)
1320 {
1321   guestfs_h *g = (guestfs_h *) (long) jg;
1322   int r;
1323
1324   r = guestfs_is_launching (g);
1325   if (r == -1) {
1326     throw_exception (env, guestfs_last_error (g));
1327     return 0;
1328   }
1329   return (jboolean) r;
1330 }
1331
1332 JNIEXPORT jboolean JNICALL
1333 Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
1334   (JNIEnv *env, jobject obj, jlong jg)
1335 {
1336   guestfs_h *g = (guestfs_h *) (long) jg;
1337   int r;
1338
1339   r = guestfs_is_busy (g);
1340   if (r == -1) {
1341     throw_exception (env, guestfs_last_error (g));
1342     return 0;
1343   }
1344   return (jboolean) r;
1345 }
1346
1347 JNIEXPORT jint JNICALL
1348 Java_com_redhat_et_libguestfs_GuestFS__1get_1state
1349   (JNIEnv *env, jobject obj, jlong jg)
1350 {
1351   guestfs_h *g = (guestfs_h *) (long) jg;
1352   int r;
1353
1354   r = guestfs_get_state (g);
1355   if (r == -1) {
1356     throw_exception (env, guestfs_last_error (g));
1357     return 0;
1358   }
1359   return (jint) r;
1360 }
1361
1362 JNIEXPORT void JNICALL
1363 Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
1364   (JNIEnv *env, jobject obj, jlong jg)
1365 {
1366   guestfs_h *g = (guestfs_h *) (long) jg;
1367   int r;
1368
1369   r = guestfs_set_busy (g);
1370   if (r == -1) {
1371     throw_exception (env, guestfs_last_error (g));
1372     return ;
1373   }
1374 }
1375
1376 JNIEXPORT void JNICALL
1377 Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
1378   (JNIEnv *env, jobject obj, jlong jg)
1379 {
1380   guestfs_h *g = (guestfs_h *) (long) jg;
1381   int r;
1382
1383   r = guestfs_set_ready (g);
1384   if (r == -1) {
1385     throw_exception (env, guestfs_last_error (g));
1386     return ;
1387   }
1388 }
1389
1390 JNIEXPORT void JNICALL
1391 Java_com_redhat_et_libguestfs_GuestFS__1end_1busy
1392   (JNIEnv *env, jobject obj, jlong jg)
1393 {
1394   guestfs_h *g = (guestfs_h *) (long) jg;
1395   int r;
1396
1397   r = guestfs_end_busy (g);
1398   if (r == -1) {
1399     throw_exception (env, guestfs_last_error (g));
1400     return ;
1401   }
1402 }
1403
1404 JNIEXPORT void JNICALL
1405 Java_com_redhat_et_libguestfs_GuestFS__1set_1memsize
1406   (JNIEnv *env, jobject obj, jlong jg, jint jmemsize)
1407 {
1408   guestfs_h *g = (guestfs_h *) (long) jg;
1409   int r;
1410   int memsize;
1411
1412   memsize = jmemsize;
1413   r = guestfs_set_memsize (g, memsize);
1414   if (r == -1) {
1415     throw_exception (env, guestfs_last_error (g));
1416     return ;
1417   }
1418 }
1419
1420 JNIEXPORT jint JNICALL
1421 Java_com_redhat_et_libguestfs_GuestFS__1get_1memsize
1422   (JNIEnv *env, jobject obj, jlong jg)
1423 {
1424   guestfs_h *g = (guestfs_h *) (long) jg;
1425   int r;
1426
1427   r = guestfs_get_memsize (g);
1428   if (r == -1) {
1429     throw_exception (env, guestfs_last_error (g));
1430     return 0;
1431   }
1432   return (jint) r;
1433 }
1434
1435 JNIEXPORT void JNICALL
1436 Java_com_redhat_et_libguestfs_GuestFS__1mount
1437   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
1438 {
1439   guestfs_h *g = (guestfs_h *) (long) jg;
1440   int r;
1441   const char *device;
1442   const char *mountpoint;
1443
1444   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1445   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
1446   r = guestfs_mount (g, device, mountpoint);
1447   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1448   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
1449   if (r == -1) {
1450     throw_exception (env, guestfs_last_error (g));
1451     return ;
1452   }
1453 }
1454
1455 JNIEXPORT void JNICALL
1456 Java_com_redhat_et_libguestfs_GuestFS__1sync
1457   (JNIEnv *env, jobject obj, jlong jg)
1458 {
1459   guestfs_h *g = (guestfs_h *) (long) jg;
1460   int r;
1461
1462   r = guestfs_sync (g);
1463   if (r == -1) {
1464     throw_exception (env, guestfs_last_error (g));
1465     return ;
1466   }
1467 }
1468
1469 JNIEXPORT void JNICALL
1470 Java_com_redhat_et_libguestfs_GuestFS__1touch
1471   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1472 {
1473   guestfs_h *g = (guestfs_h *) (long) jg;
1474   int r;
1475   const char *path;
1476
1477   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1478   r = guestfs_touch (g, path);
1479   (*env)->ReleaseStringUTFChars (env, jpath, path);
1480   if (r == -1) {
1481     throw_exception (env, guestfs_last_error (g));
1482     return ;
1483   }
1484 }
1485
1486 JNIEXPORT jstring JNICALL
1487 Java_com_redhat_et_libguestfs_GuestFS__1cat
1488   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1489 {
1490   guestfs_h *g = (guestfs_h *) (long) jg;
1491   jstring jr;
1492   char *r;
1493   const char *path;
1494
1495   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1496   r = guestfs_cat (g, path);
1497   (*env)->ReleaseStringUTFChars (env, jpath, path);
1498   if (r == NULL) {
1499     throw_exception (env, guestfs_last_error (g));
1500     return NULL;
1501   }
1502   jr = (*env)->NewStringUTF (env, r);
1503   free (r);
1504   return jr;
1505 }
1506
1507 JNIEXPORT jstring JNICALL
1508 Java_com_redhat_et_libguestfs_GuestFS__1ll
1509   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1510 {
1511   guestfs_h *g = (guestfs_h *) (long) jg;
1512   jstring jr;
1513   char *r;
1514   const char *directory;
1515
1516   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1517   r = guestfs_ll (g, directory);
1518   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1519   if (r == NULL) {
1520     throw_exception (env, guestfs_last_error (g));
1521     return NULL;
1522   }
1523   jr = (*env)->NewStringUTF (env, r);
1524   free (r);
1525   return jr;
1526 }
1527
1528 JNIEXPORT jobjectArray JNICALL
1529 Java_com_redhat_et_libguestfs_GuestFS__1ls
1530   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1531 {
1532   guestfs_h *g = (guestfs_h *) (long) jg;
1533   jobjectArray jr;
1534   int r_len;
1535   jclass cl;
1536   jstring jstr;
1537   char **r;
1538   const char *directory;
1539   int i;
1540
1541   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1542   r = guestfs_ls (g, directory);
1543   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1544   if (r == NULL) {
1545     throw_exception (env, guestfs_last_error (g));
1546     return NULL;
1547   }
1548   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1549   cl = (*env)->FindClass (env, "java/lang/String");
1550   jstr = (*env)->NewStringUTF (env, "");
1551   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1552   for (i = 0; i < r_len; ++i) {
1553     jstr = (*env)->NewStringUTF (env, r[i]);
1554     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1555     free (r[i]);
1556   }
1557   free (r);
1558   return jr;
1559 }
1560
1561 JNIEXPORT jobjectArray JNICALL
1562 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
1563   (JNIEnv *env, jobject obj, jlong jg)
1564 {
1565   guestfs_h *g = (guestfs_h *) (long) jg;
1566   jobjectArray jr;
1567   int r_len;
1568   jclass cl;
1569   jstring jstr;
1570   char **r;
1571   int i;
1572
1573   r = guestfs_list_devices (g);
1574   if (r == NULL) {
1575     throw_exception (env, guestfs_last_error (g));
1576     return NULL;
1577   }
1578   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1579   cl = (*env)->FindClass (env, "java/lang/String");
1580   jstr = (*env)->NewStringUTF (env, "");
1581   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1582   for (i = 0; i < r_len; ++i) {
1583     jstr = (*env)->NewStringUTF (env, r[i]);
1584     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1585     free (r[i]);
1586   }
1587   free (r);
1588   return jr;
1589 }
1590
1591 JNIEXPORT jobjectArray JNICALL
1592 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
1593   (JNIEnv *env, jobject obj, jlong jg)
1594 {
1595   guestfs_h *g = (guestfs_h *) (long) jg;
1596   jobjectArray jr;
1597   int r_len;
1598   jclass cl;
1599   jstring jstr;
1600   char **r;
1601   int i;
1602
1603   r = guestfs_list_partitions (g);
1604   if (r == NULL) {
1605     throw_exception (env, guestfs_last_error (g));
1606     return NULL;
1607   }
1608   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1609   cl = (*env)->FindClass (env, "java/lang/String");
1610   jstr = (*env)->NewStringUTF (env, "");
1611   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1612   for (i = 0; i < r_len; ++i) {
1613     jstr = (*env)->NewStringUTF (env, r[i]);
1614     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1615     free (r[i]);
1616   }
1617   free (r);
1618   return jr;
1619 }
1620
1621 JNIEXPORT jobjectArray JNICALL
1622 Java_com_redhat_et_libguestfs_GuestFS__1pvs
1623   (JNIEnv *env, jobject obj, jlong jg)
1624 {
1625   guestfs_h *g = (guestfs_h *) (long) jg;
1626   jobjectArray jr;
1627   int r_len;
1628   jclass cl;
1629   jstring jstr;
1630   char **r;
1631   int i;
1632
1633   r = guestfs_pvs (g);
1634   if (r == NULL) {
1635     throw_exception (env, guestfs_last_error (g));
1636     return NULL;
1637   }
1638   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1639   cl = (*env)->FindClass (env, "java/lang/String");
1640   jstr = (*env)->NewStringUTF (env, "");
1641   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1642   for (i = 0; i < r_len; ++i) {
1643     jstr = (*env)->NewStringUTF (env, r[i]);
1644     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1645     free (r[i]);
1646   }
1647   free (r);
1648   return jr;
1649 }
1650
1651 JNIEXPORT jobjectArray JNICALL
1652 Java_com_redhat_et_libguestfs_GuestFS__1vgs
1653   (JNIEnv *env, jobject obj, jlong jg)
1654 {
1655   guestfs_h *g = (guestfs_h *) (long) jg;
1656   jobjectArray jr;
1657   int r_len;
1658   jclass cl;
1659   jstring jstr;
1660   char **r;
1661   int i;
1662
1663   r = guestfs_vgs (g);
1664   if (r == NULL) {
1665     throw_exception (env, guestfs_last_error (g));
1666     return NULL;
1667   }
1668   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1669   cl = (*env)->FindClass (env, "java/lang/String");
1670   jstr = (*env)->NewStringUTF (env, "");
1671   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1672   for (i = 0; i < r_len; ++i) {
1673     jstr = (*env)->NewStringUTF (env, r[i]);
1674     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1675     free (r[i]);
1676   }
1677   free (r);
1678   return jr;
1679 }
1680
1681 JNIEXPORT jobjectArray JNICALL
1682 Java_com_redhat_et_libguestfs_GuestFS__1lvs
1683   (JNIEnv *env, jobject obj, jlong jg)
1684 {
1685   guestfs_h *g = (guestfs_h *) (long) jg;
1686   jobjectArray jr;
1687   int r_len;
1688   jclass cl;
1689   jstring jstr;
1690   char **r;
1691   int i;
1692
1693   r = guestfs_lvs (g);
1694   if (r == NULL) {
1695     throw_exception (env, guestfs_last_error (g));
1696     return NULL;
1697   }
1698   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1699   cl = (*env)->FindClass (env, "java/lang/String");
1700   jstr = (*env)->NewStringUTF (env, "");
1701   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1702   for (i = 0; i < r_len; ++i) {
1703     jstr = (*env)->NewStringUTF (env, r[i]);
1704     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1705     free (r[i]);
1706   }
1707   free (r);
1708   return jr;
1709 }
1710
1711 JNIEXPORT jobjectArray JNICALL
1712 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
1713   (JNIEnv *env, jobject obj, jlong jg)
1714 {
1715   guestfs_h *g = (guestfs_h *) (long) jg;
1716   jobjectArray jr;
1717   jclass cl;
1718   jfieldID fl;
1719   jobject jfl;
1720   struct guestfs_lvm_pv_list *r;
1721   int i;
1722
1723   r = guestfs_pvs_full (g);
1724   if (r == NULL) {
1725     throw_exception (env, guestfs_last_error (g));
1726     return NULL;
1727   }
1728   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
1729   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1730   for (i = 0; i < r->len; ++i) {
1731     jfl = (*env)->AllocObject (env, cl);
1732     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
1733     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
1734     {
1735       char s[33];
1736       memcpy (s, r->val[i].pv_uuid, 32);
1737       s[32] = 0;
1738       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
1739       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1740     }
1741     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
1742     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
1743     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
1744     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
1745     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
1746     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
1747     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
1748     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
1749     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
1750     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
1751     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
1752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
1753     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
1754     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
1755     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
1756     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
1757     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
1758     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
1759     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
1760     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
1761     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
1762     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
1763     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
1764     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
1765     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1766   }
1767   guestfs_free_lvm_pv_list (r);
1768   return jr;
1769 }
1770
1771 JNIEXPORT jobjectArray JNICALL
1772 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
1773   (JNIEnv *env, jobject obj, jlong jg)
1774 {
1775   guestfs_h *g = (guestfs_h *) (long) jg;
1776   jobjectArray jr;
1777   jclass cl;
1778   jfieldID fl;
1779   jobject jfl;
1780   struct guestfs_lvm_vg_list *r;
1781   int i;
1782
1783   r = guestfs_vgs_full (g);
1784   if (r == NULL) {
1785     throw_exception (env, guestfs_last_error (g));
1786     return NULL;
1787   }
1788   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
1789   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1790   for (i = 0; i < r->len; ++i) {
1791     jfl = (*env)->AllocObject (env, cl);
1792     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
1793     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
1794     {
1795       char s[33];
1796       memcpy (s, r->val[i].vg_uuid, 32);
1797       s[32] = 0;
1798       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
1799       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1800     }
1801     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
1802     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
1803     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
1804     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
1805     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
1806     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
1807     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
1808     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
1809     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
1810     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
1811     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
1812     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
1813     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
1814     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
1815     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
1816     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
1817     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
1818     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
1819     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
1820     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
1821     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
1822     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
1823     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
1824     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
1825     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
1826     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
1827     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
1828     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
1829     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
1830     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
1831     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
1832     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
1833     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
1834     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
1835     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1836   }
1837   guestfs_free_lvm_vg_list (r);
1838   return jr;
1839 }
1840
1841 JNIEXPORT jobjectArray JNICALL
1842 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
1843   (JNIEnv *env, jobject obj, jlong jg)
1844 {
1845   guestfs_h *g = (guestfs_h *) (long) jg;
1846   jobjectArray jr;
1847   jclass cl;
1848   jfieldID fl;
1849   jobject jfl;
1850   struct guestfs_lvm_lv_list *r;
1851   int i;
1852
1853   r = guestfs_lvs_full (g);
1854   if (r == NULL) {
1855     throw_exception (env, guestfs_last_error (g));
1856     return NULL;
1857   }
1858   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
1859   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1860   for (i = 0; i < r->len; ++i) {
1861     jfl = (*env)->AllocObject (env, cl);
1862     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
1863     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
1864     {
1865       char s[33];
1866       memcpy (s, r->val[i].lv_uuid, 32);
1867       s[32] = 0;
1868       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
1869       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1870     }
1871     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
1872     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
1873     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
1874     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
1875     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
1876     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
1877     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
1878     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
1879     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
1880     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
1881     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
1882     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
1883     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
1884     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
1885     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
1886     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
1887     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
1888     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
1889     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
1890     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
1891     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
1892     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
1893     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
1894     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
1895     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
1896     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
1897     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
1898     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
1899     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1900   }
1901   guestfs_free_lvm_lv_list (r);
1902   return jr;
1903 }
1904
1905 JNIEXPORT jobjectArray JNICALL
1906 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
1907   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1908 {
1909   guestfs_h *g = (guestfs_h *) (long) jg;
1910   jobjectArray jr;
1911   int r_len;
1912   jclass cl;
1913   jstring jstr;
1914   char **r;
1915   const char *path;
1916   int i;
1917
1918   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1919   r = guestfs_read_lines (g, path);
1920   (*env)->ReleaseStringUTFChars (env, jpath, path);
1921   if (r == NULL) {
1922     throw_exception (env, guestfs_last_error (g));
1923     return NULL;
1924   }
1925   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1926   cl = (*env)->FindClass (env, "java/lang/String");
1927   jstr = (*env)->NewStringUTF (env, "");
1928   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1929   for (i = 0; i < r_len; ++i) {
1930     jstr = (*env)->NewStringUTF (env, r[i]);
1931     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1932     free (r[i]);
1933   }
1934   free (r);
1935   return jr;
1936 }
1937
1938 JNIEXPORT void JNICALL
1939 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
1940   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
1941 {
1942   guestfs_h *g = (guestfs_h *) (long) jg;
1943   int r;
1944   const char *root;
1945   int flags;
1946
1947   root = (*env)->GetStringUTFChars (env, jroot, NULL);
1948   flags = jflags;
1949   r = guestfs_aug_init (g, root, flags);
1950   (*env)->ReleaseStringUTFChars (env, jroot, root);
1951   if (r == -1) {
1952     throw_exception (env, guestfs_last_error (g));
1953     return ;
1954   }
1955 }
1956
1957 JNIEXPORT void JNICALL
1958 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
1959   (JNIEnv *env, jobject obj, jlong jg)
1960 {
1961   guestfs_h *g = (guestfs_h *) (long) jg;
1962   int r;
1963
1964   r = guestfs_aug_close (g);
1965   if (r == -1) {
1966     throw_exception (env, guestfs_last_error (g));
1967     return ;
1968   }
1969 }
1970
1971 JNIEXPORT jint JNICALL
1972 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
1973   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
1974 {
1975   guestfs_h *g = (guestfs_h *) (long) jg;
1976   int r;
1977   const char *name;
1978   const char *expr;
1979
1980   name = (*env)->GetStringUTFChars (env, jname, NULL);
1981   expr = jexpr ? (*env)->GetStringUTFChars (env, jexpr, NULL) : NULL;
1982   r = guestfs_aug_defvar (g, name, expr);
1983   (*env)->ReleaseStringUTFChars (env, jname, name);
1984   if (jexpr)
1985     (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1986   if (r == -1) {
1987     throw_exception (env, guestfs_last_error (g));
1988     return 0;
1989   }
1990   return (jint) r;
1991 }
1992
1993 JNIEXPORT jobject JNICALL
1994 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
1995   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
1996 {
1997   guestfs_h *g = (guestfs_h *) (long) jg;
1998   jobject jr;
1999   jclass cl;
2000   jfieldID fl;
2001   struct guestfs_int_bool *r;
2002   const char *name;
2003   const char *expr;
2004   const char *val;
2005
2006   name = (*env)->GetStringUTFChars (env, jname, NULL);
2007   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
2008   val = (*env)->GetStringUTFChars (env, jval, NULL);
2009   r = guestfs_aug_defnode (g, name, expr, val);
2010   (*env)->ReleaseStringUTFChars (env, jname, name);
2011   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
2012   (*env)->ReleaseStringUTFChars (env, jval, val);
2013   if (r == NULL) {
2014     throw_exception (env, guestfs_last_error (g));
2015     return NULL;
2016   }
2017   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
2018   jr = (*env)->AllocObject (env, cl);
2019   fl = (*env)->GetFieldID (env, cl, "i", "I");
2020   (*env)->SetIntField (env, jr, fl, r->i);
2021   fl = (*env)->GetFieldID (env, cl, "i", "Z");
2022   (*env)->SetBooleanField (env, jr, fl, r->b);
2023   guestfs_free_int_bool (r);
2024   return jr;
2025 }
2026
2027 JNIEXPORT jstring JNICALL
2028 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
2029   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2030 {
2031   guestfs_h *g = (guestfs_h *) (long) jg;
2032   jstring jr;
2033   char *r;
2034   const char *path;
2035
2036   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2037   r = guestfs_aug_get (g, path);
2038   (*env)->ReleaseStringUTFChars (env, jpath, path);
2039   if (r == NULL) {
2040     throw_exception (env, guestfs_last_error (g));
2041     return NULL;
2042   }
2043   jr = (*env)->NewStringUTF (env, r);
2044   free (r);
2045   return jr;
2046 }
2047
2048 JNIEXPORT void JNICALL
2049 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
2050   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
2051 {
2052   guestfs_h *g = (guestfs_h *) (long) jg;
2053   int r;
2054   const char *path;
2055   const char *val;
2056
2057   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2058   val = (*env)->GetStringUTFChars (env, jval, NULL);
2059   r = guestfs_aug_set (g, path, val);
2060   (*env)->ReleaseStringUTFChars (env, jpath, path);
2061   (*env)->ReleaseStringUTFChars (env, jval, val);
2062   if (r == -1) {
2063     throw_exception (env, guestfs_last_error (g));
2064     return ;
2065   }
2066 }
2067
2068 JNIEXPORT void JNICALL
2069 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
2070   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
2071 {
2072   guestfs_h *g = (guestfs_h *) (long) jg;
2073   int r;
2074   const char *path;
2075   const char *label;
2076   int before;
2077
2078   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2079   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2080   before = jbefore;
2081   r = guestfs_aug_insert (g, path, label, before);
2082   (*env)->ReleaseStringUTFChars (env, jpath, path);
2083   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2084   if (r == -1) {
2085     throw_exception (env, guestfs_last_error (g));
2086     return ;
2087   }
2088 }
2089
2090 JNIEXPORT jint JNICALL
2091 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
2092   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2093 {
2094   guestfs_h *g = (guestfs_h *) (long) jg;
2095   int r;
2096   const char *path;
2097
2098   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2099   r = guestfs_aug_rm (g, path);
2100   (*env)->ReleaseStringUTFChars (env, jpath, path);
2101   if (r == -1) {
2102     throw_exception (env, guestfs_last_error (g));
2103     return 0;
2104   }
2105   return (jint) r;
2106 }
2107
2108 JNIEXPORT void JNICALL
2109 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
2110   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2111 {
2112   guestfs_h *g = (guestfs_h *) (long) jg;
2113   int r;
2114   const char *src;
2115   const char *dest;
2116
2117   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2118   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2119   r = guestfs_aug_mv (g, src, dest);
2120   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2121   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2122   if (r == -1) {
2123     throw_exception (env, guestfs_last_error (g));
2124     return ;
2125   }
2126 }
2127
2128 JNIEXPORT jobjectArray JNICALL
2129 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
2130   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2131 {
2132   guestfs_h *g = (guestfs_h *) (long) jg;
2133   jobjectArray jr;
2134   int r_len;
2135   jclass cl;
2136   jstring jstr;
2137   char **r;
2138   const char *path;
2139   int i;
2140
2141   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2142   r = guestfs_aug_match (g, path);
2143   (*env)->ReleaseStringUTFChars (env, jpath, path);
2144   if (r == NULL) {
2145     throw_exception (env, guestfs_last_error (g));
2146     return NULL;
2147   }
2148   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2149   cl = (*env)->FindClass (env, "java/lang/String");
2150   jstr = (*env)->NewStringUTF (env, "");
2151   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2152   for (i = 0; i < r_len; ++i) {
2153     jstr = (*env)->NewStringUTF (env, r[i]);
2154     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2155     free (r[i]);
2156   }
2157   free (r);
2158   return jr;
2159 }
2160
2161 JNIEXPORT void JNICALL
2162 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
2163   (JNIEnv *env, jobject obj, jlong jg)
2164 {
2165   guestfs_h *g = (guestfs_h *) (long) jg;
2166   int r;
2167
2168   r = guestfs_aug_save (g);
2169   if (r == -1) {
2170     throw_exception (env, guestfs_last_error (g));
2171     return ;
2172   }
2173 }
2174
2175 JNIEXPORT void JNICALL
2176 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
2177   (JNIEnv *env, jobject obj, jlong jg)
2178 {
2179   guestfs_h *g = (guestfs_h *) (long) jg;
2180   int r;
2181
2182   r = guestfs_aug_load (g);
2183   if (r == -1) {
2184     throw_exception (env, guestfs_last_error (g));
2185     return ;
2186   }
2187 }
2188
2189 JNIEXPORT jobjectArray JNICALL
2190 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
2191   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2192 {
2193   guestfs_h *g = (guestfs_h *) (long) jg;
2194   jobjectArray jr;
2195   int r_len;
2196   jclass cl;
2197   jstring jstr;
2198   char **r;
2199   const char *path;
2200   int i;
2201
2202   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2203   r = guestfs_aug_ls (g, path);
2204   (*env)->ReleaseStringUTFChars (env, jpath, path);
2205   if (r == NULL) {
2206     throw_exception (env, guestfs_last_error (g));
2207     return NULL;
2208   }
2209   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2210   cl = (*env)->FindClass (env, "java/lang/String");
2211   jstr = (*env)->NewStringUTF (env, "");
2212   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2213   for (i = 0; i < r_len; ++i) {
2214     jstr = (*env)->NewStringUTF (env, r[i]);
2215     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2216     free (r[i]);
2217   }
2218   free (r);
2219   return jr;
2220 }
2221
2222 JNIEXPORT void JNICALL
2223 Java_com_redhat_et_libguestfs_GuestFS__1rm
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_rm (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__1rmdir
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_rmdir (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__1rm_1rf
2258   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2259 {
2260   guestfs_h *g = (guestfs_h *) (long) jg;
2261   int r;
2262   const char *path;
2263
2264   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2265   r = guestfs_rm_rf (g, path);
2266   (*env)->ReleaseStringUTFChars (env, jpath, path);
2267   if (r == -1) {
2268     throw_exception (env, guestfs_last_error (g));
2269     return ;
2270   }
2271 }
2272
2273 JNIEXPORT void JNICALL
2274 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
2275   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2276 {
2277   guestfs_h *g = (guestfs_h *) (long) jg;
2278   int r;
2279   const char *path;
2280
2281   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2282   r = guestfs_mkdir (g, path);
2283   (*env)->ReleaseStringUTFChars (env, jpath, path);
2284   if (r == -1) {
2285     throw_exception (env, guestfs_last_error (g));
2286     return ;
2287   }
2288 }
2289
2290 JNIEXPORT void JNICALL
2291 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
2292   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2293 {
2294   guestfs_h *g = (guestfs_h *) (long) jg;
2295   int r;
2296   const char *path;
2297
2298   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2299   r = guestfs_mkdir_p (g, path);
2300   (*env)->ReleaseStringUTFChars (env, jpath, path);
2301   if (r == -1) {
2302     throw_exception (env, guestfs_last_error (g));
2303     return ;
2304   }
2305 }
2306
2307 JNIEXPORT void JNICALL
2308 Java_com_redhat_et_libguestfs_GuestFS__1chmod
2309   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
2310 {
2311   guestfs_h *g = (guestfs_h *) (long) jg;
2312   int r;
2313   int mode;
2314   const char *path;
2315
2316   mode = jmode;
2317   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2318   r = guestfs_chmod (g, mode, path);
2319   (*env)->ReleaseStringUTFChars (env, jpath, path);
2320   if (r == -1) {
2321     throw_exception (env, guestfs_last_error (g));
2322     return ;
2323   }
2324 }
2325
2326 JNIEXPORT void JNICALL
2327 Java_com_redhat_et_libguestfs_GuestFS__1chown
2328   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
2329 {
2330   guestfs_h *g = (guestfs_h *) (long) jg;
2331   int r;
2332   int owner;
2333   int group;
2334   const char *path;
2335
2336   owner = jowner;
2337   group = jgroup;
2338   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2339   r = guestfs_chown (g, owner, group, path);
2340   (*env)->ReleaseStringUTFChars (env, jpath, path);
2341   if (r == -1) {
2342     throw_exception (env, guestfs_last_error (g));
2343     return ;
2344   }
2345 }
2346
2347 JNIEXPORT jboolean JNICALL
2348 Java_com_redhat_et_libguestfs_GuestFS__1exists
2349   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2350 {
2351   guestfs_h *g = (guestfs_h *) (long) jg;
2352   int r;
2353   const char *path;
2354
2355   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2356   r = guestfs_exists (g, path);
2357   (*env)->ReleaseStringUTFChars (env, jpath, path);
2358   if (r == -1) {
2359     throw_exception (env, guestfs_last_error (g));
2360     return 0;
2361   }
2362   return (jboolean) r;
2363 }
2364
2365 JNIEXPORT jboolean JNICALL
2366 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
2367   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2368 {
2369   guestfs_h *g = (guestfs_h *) (long) jg;
2370   int r;
2371   const char *path;
2372
2373   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2374   r = guestfs_is_file (g, path);
2375   (*env)->ReleaseStringUTFChars (env, jpath, path);
2376   if (r == -1) {
2377     throw_exception (env, guestfs_last_error (g));
2378     return 0;
2379   }
2380   return (jboolean) r;
2381 }
2382
2383 JNIEXPORT jboolean JNICALL
2384 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
2385   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2386 {
2387   guestfs_h *g = (guestfs_h *) (long) jg;
2388   int r;
2389   const char *path;
2390
2391   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2392   r = guestfs_is_dir (g, path);
2393   (*env)->ReleaseStringUTFChars (env, jpath, path);
2394   if (r == -1) {
2395     throw_exception (env, guestfs_last_error (g));
2396     return 0;
2397   }
2398   return (jboolean) r;
2399 }
2400
2401 JNIEXPORT void JNICALL
2402 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
2403   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2404 {
2405   guestfs_h *g = (guestfs_h *) (long) jg;
2406   int r;
2407   const char *device;
2408
2409   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2410   r = guestfs_pvcreate (g, device);
2411   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2412   if (r == -1) {
2413     throw_exception (env, guestfs_last_error (g));
2414     return ;
2415   }
2416 }
2417
2418 JNIEXPORT void JNICALL
2419 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
2420   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
2421 {
2422   guestfs_h *g = (guestfs_h *) (long) jg;
2423   int r;
2424   const char *volgroup;
2425   int physvols_len;
2426   const char **physvols;
2427   int i;
2428
2429   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2430   physvols_len = (*env)->GetArrayLength (env, jphysvols);
2431   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
2432   for (i = 0; i < physvols_len; ++i) {
2433     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2434     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
2435   }
2436   physvols[physvols_len] = NULL;
2437   r = guestfs_vgcreate (g, volgroup, physvols);
2438   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2439   for (i = 0; i < physvols_len; ++i) {
2440     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2441     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
2442   }
2443   free (physvols);
2444   if (r == -1) {
2445     throw_exception (env, guestfs_last_error (g));
2446     return ;
2447   }
2448 }
2449
2450 JNIEXPORT void JNICALL
2451 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
2452   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
2453 {
2454   guestfs_h *g = (guestfs_h *) (long) jg;
2455   int r;
2456   const char *logvol;
2457   const char *volgroup;
2458   int mbytes;
2459
2460   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
2461   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2462   mbytes = jmbytes;
2463   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2464   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
2465   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2466   if (r == -1) {
2467     throw_exception (env, guestfs_last_error (g));
2468     return ;
2469   }
2470 }
2471
2472 JNIEXPORT void JNICALL
2473 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
2474   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2475 {
2476   guestfs_h *g = (guestfs_h *) (long) jg;
2477   int r;
2478   const char *fstype;
2479   const char *device;
2480
2481   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2482   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2483   r = guestfs_mkfs (g, fstype, device);
2484   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2485   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2486   if (r == -1) {
2487     throw_exception (env, guestfs_last_error (g));
2488     return ;
2489   }
2490 }
2491
2492 JNIEXPORT void JNICALL
2493 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
2494   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
2495 {
2496   guestfs_h *g = (guestfs_h *) (long) jg;
2497   int r;
2498   const char *device;
2499   int cyls;
2500   int heads;
2501   int sectors;
2502   int lines_len;
2503   const char **lines;
2504   int i;
2505
2506   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2507   cyls = jcyls;
2508   heads = jheads;
2509   sectors = jsectors;
2510   lines_len = (*env)->GetArrayLength (env, jlines);
2511   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
2512   for (i = 0; i < lines_len; ++i) {
2513     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2514     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
2515   }
2516   lines[lines_len] = NULL;
2517   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2518   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2519   for (i = 0; i < lines_len; ++i) {
2520     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2521     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
2522   }
2523   free (lines);
2524   if (r == -1) {
2525     throw_exception (env, guestfs_last_error (g));
2526     return ;
2527   }
2528 }
2529
2530 JNIEXPORT void JNICALL
2531 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
2532   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
2533 {
2534   guestfs_h *g = (guestfs_h *) (long) jg;
2535   int r;
2536   const char *path;
2537   const char *content;
2538   int size;
2539
2540   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2541   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
2542   size = jsize;
2543   r = guestfs_write_file (g, path, content, size);
2544   (*env)->ReleaseStringUTFChars (env, jpath, path);
2545   (*env)->ReleaseStringUTFChars (env, jcontent, content);
2546   if (r == -1) {
2547     throw_exception (env, guestfs_last_error (g));
2548     return ;
2549   }
2550 }
2551
2552 JNIEXPORT void JNICALL
2553 Java_com_redhat_et_libguestfs_GuestFS__1umount
2554   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
2555 {
2556   guestfs_h *g = (guestfs_h *) (long) jg;
2557   int r;
2558   const char *pathordevice;
2559
2560   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
2561   r = guestfs_umount (g, pathordevice);
2562   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
2563   if (r == -1) {
2564     throw_exception (env, guestfs_last_error (g));
2565     return ;
2566   }
2567 }
2568
2569 JNIEXPORT jobjectArray JNICALL
2570 Java_com_redhat_et_libguestfs_GuestFS__1mounts
2571   (JNIEnv *env, jobject obj, jlong jg)
2572 {
2573   guestfs_h *g = (guestfs_h *) (long) jg;
2574   jobjectArray jr;
2575   int r_len;
2576   jclass cl;
2577   jstring jstr;
2578   char **r;
2579   int i;
2580
2581   r = guestfs_mounts (g);
2582   if (r == NULL) {
2583     throw_exception (env, guestfs_last_error (g));
2584     return NULL;
2585   }
2586   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2587   cl = (*env)->FindClass (env, "java/lang/String");
2588   jstr = (*env)->NewStringUTF (env, "");
2589   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2590   for (i = 0; i < r_len; ++i) {
2591     jstr = (*env)->NewStringUTF (env, r[i]);
2592     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2593     free (r[i]);
2594   }
2595   free (r);
2596   return jr;
2597 }
2598
2599 JNIEXPORT void JNICALL
2600 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
2601   (JNIEnv *env, jobject obj, jlong jg)
2602 {
2603   guestfs_h *g = (guestfs_h *) (long) jg;
2604   int r;
2605
2606   r = guestfs_umount_all (g);
2607   if (r == -1) {
2608     throw_exception (env, guestfs_last_error (g));
2609     return ;
2610   }
2611 }
2612
2613 JNIEXPORT void JNICALL
2614 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
2615   (JNIEnv *env, jobject obj, jlong jg)
2616 {
2617   guestfs_h *g = (guestfs_h *) (long) jg;
2618   int r;
2619
2620   r = guestfs_lvm_remove_all (g);
2621   if (r == -1) {
2622     throw_exception (env, guestfs_last_error (g));
2623     return ;
2624   }
2625 }
2626
2627 JNIEXPORT jstring JNICALL
2628 Java_com_redhat_et_libguestfs_GuestFS__1file
2629   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2630 {
2631   guestfs_h *g = (guestfs_h *) (long) jg;
2632   jstring jr;
2633   char *r;
2634   const char *path;
2635
2636   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2637   r = guestfs_file (g, path);
2638   (*env)->ReleaseStringUTFChars (env, jpath, path);
2639   if (r == NULL) {
2640     throw_exception (env, guestfs_last_error (g));
2641     return NULL;
2642   }
2643   jr = (*env)->NewStringUTF (env, r);
2644   free (r);
2645   return jr;
2646 }
2647
2648 JNIEXPORT jstring JNICALL
2649 Java_com_redhat_et_libguestfs_GuestFS__1command
2650   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2651 {
2652   guestfs_h *g = (guestfs_h *) (long) jg;
2653   jstring jr;
2654   char *r;
2655   int arguments_len;
2656   const char **arguments;
2657   int i;
2658
2659   arguments_len = (*env)->GetArrayLength (env, jarguments);
2660   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2661   for (i = 0; i < arguments_len; ++i) {
2662     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2663     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2664   }
2665   arguments[arguments_len] = NULL;
2666   r = guestfs_command (g, arguments);
2667   for (i = 0; i < arguments_len; ++i) {
2668     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2669     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2670   }
2671   free (arguments);
2672   if (r == NULL) {
2673     throw_exception (env, guestfs_last_error (g));
2674     return NULL;
2675   }
2676   jr = (*env)->NewStringUTF (env, r);
2677   free (r);
2678   return jr;
2679 }
2680
2681 JNIEXPORT jobjectArray JNICALL
2682 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
2683   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2684 {
2685   guestfs_h *g = (guestfs_h *) (long) jg;
2686   jobjectArray jr;
2687   int r_len;
2688   jclass cl;
2689   jstring jstr;
2690   char **r;
2691   int arguments_len;
2692   const char **arguments;
2693   int i;
2694
2695   arguments_len = (*env)->GetArrayLength (env, jarguments);
2696   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2697   for (i = 0; i < arguments_len; ++i) {
2698     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2699     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2700   }
2701   arguments[arguments_len] = NULL;
2702   r = guestfs_command_lines (g, arguments);
2703   for (i = 0; i < arguments_len; ++i) {
2704     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2705     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2706   }
2707   free (arguments);
2708   if (r == NULL) {
2709     throw_exception (env, guestfs_last_error (g));
2710     return NULL;
2711   }
2712   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2713   cl = (*env)->FindClass (env, "java/lang/String");
2714   jstr = (*env)->NewStringUTF (env, "");
2715   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2716   for (i = 0; i < r_len; ++i) {
2717     jstr = (*env)->NewStringUTF (env, r[i]);
2718     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2719     free (r[i]);
2720   }
2721   free (r);
2722   return jr;
2723 }
2724
2725 JNIEXPORT jobject JNICALL
2726 Java_com_redhat_et_libguestfs_GuestFS__1stat
2727   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2728 {
2729   guestfs_h *g = (guestfs_h *) (long) jg;
2730   jobject jr;
2731   jclass cl;
2732   jfieldID fl;
2733   struct guestfs_stat *r;
2734   const char *path;
2735
2736   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2737   r = guestfs_stat (g, path);
2738   (*env)->ReleaseStringUTFChars (env, jpath, path);
2739   if (r == NULL) {
2740     throw_exception (env, guestfs_last_error (g));
2741     return NULL;
2742   }
2743   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2744   jr = (*env)->AllocObject (env, cl);
2745   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2746   (*env)->SetLongField (env, jr, fl, r->dev);
2747   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2748   (*env)->SetLongField (env, jr, fl, r->ino);
2749   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2750   (*env)->SetLongField (env, jr, fl, r->mode);
2751   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2752   (*env)->SetLongField (env, jr, fl, r->nlink);
2753   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2754   (*env)->SetLongField (env, jr, fl, r->uid);
2755   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2756   (*env)->SetLongField (env, jr, fl, r->gid);
2757   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2758   (*env)->SetLongField (env, jr, fl, r->rdev);
2759   fl = (*env)->GetFieldID (env, cl, "size", "J");
2760   (*env)->SetLongField (env, jr, fl, r->size);
2761   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2762   (*env)->SetLongField (env, jr, fl, r->blksize);
2763   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2764   (*env)->SetLongField (env, jr, fl, r->blocks);
2765   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2766   (*env)->SetLongField (env, jr, fl, r->atime);
2767   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2768   (*env)->SetLongField (env, jr, fl, r->mtime);
2769   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2770   (*env)->SetLongField (env, jr, fl, r->ctime);
2771   free (r);
2772   return jr;
2773 }
2774
2775 JNIEXPORT jobject JNICALL
2776 Java_com_redhat_et_libguestfs_GuestFS__1lstat
2777   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2778 {
2779   guestfs_h *g = (guestfs_h *) (long) jg;
2780   jobject jr;
2781   jclass cl;
2782   jfieldID fl;
2783   struct guestfs_stat *r;
2784   const char *path;
2785
2786   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2787   r = guestfs_lstat (g, path);
2788   (*env)->ReleaseStringUTFChars (env, jpath, path);
2789   if (r == NULL) {
2790     throw_exception (env, guestfs_last_error (g));
2791     return NULL;
2792   }
2793   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2794   jr = (*env)->AllocObject (env, cl);
2795   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2796   (*env)->SetLongField (env, jr, fl, r->dev);
2797   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2798   (*env)->SetLongField (env, jr, fl, r->ino);
2799   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2800   (*env)->SetLongField (env, jr, fl, r->mode);
2801   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2802   (*env)->SetLongField (env, jr, fl, r->nlink);
2803   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2804   (*env)->SetLongField (env, jr, fl, r->uid);
2805   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2806   (*env)->SetLongField (env, jr, fl, r->gid);
2807   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2808   (*env)->SetLongField (env, jr, fl, r->rdev);
2809   fl = (*env)->GetFieldID (env, cl, "size", "J");
2810   (*env)->SetLongField (env, jr, fl, r->size);
2811   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2812   (*env)->SetLongField (env, jr, fl, r->blksize);
2813   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2814   (*env)->SetLongField (env, jr, fl, r->blocks);
2815   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2816   (*env)->SetLongField (env, jr, fl, r->atime);
2817   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2818   (*env)->SetLongField (env, jr, fl, r->mtime);
2819   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2820   (*env)->SetLongField (env, jr, fl, r->ctime);
2821   free (r);
2822   return jr;
2823 }
2824
2825 JNIEXPORT jobject JNICALL
2826 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
2827   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2828 {
2829   guestfs_h *g = (guestfs_h *) (long) jg;
2830   jobject jr;
2831   jclass cl;
2832   jfieldID fl;
2833   struct guestfs_statvfs *r;
2834   const char *path;
2835
2836   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2837   r = guestfs_statvfs (g, path);
2838   (*env)->ReleaseStringUTFChars (env, jpath, path);
2839   if (r == NULL) {
2840     throw_exception (env, guestfs_last_error (g));
2841     return NULL;
2842   }
2843   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
2844   jr = (*env)->AllocObject (env, cl);
2845   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
2846   (*env)->SetLongField (env, jr, fl, r->bsize);
2847   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
2848   (*env)->SetLongField (env, jr, fl, r->frsize);
2849   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2850   (*env)->SetLongField (env, jr, fl, r->blocks);
2851   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
2852   (*env)->SetLongField (env, jr, fl, r->bfree);
2853   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
2854   (*env)->SetLongField (env, jr, fl, r->bavail);
2855   fl = (*env)->GetFieldID (env, cl, "files", "J");
2856   (*env)->SetLongField (env, jr, fl, r->files);
2857   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
2858   (*env)->SetLongField (env, jr, fl, r->ffree);
2859   fl = (*env)->GetFieldID (env, cl, "favail", "J");
2860   (*env)->SetLongField (env, jr, fl, r->favail);
2861   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
2862   (*env)->SetLongField (env, jr, fl, r->fsid);
2863   fl = (*env)->GetFieldID (env, cl, "flag", "J");
2864   (*env)->SetLongField (env, jr, fl, r->flag);
2865   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
2866   (*env)->SetLongField (env, jr, fl, r->namemax);
2867   free (r);
2868   return jr;
2869 }
2870
2871 JNIEXPORT jobject JNICALL
2872 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
2873   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2874 {
2875   guestfs_h *g = (guestfs_h *) (long) jg;
2876   char **r;
2877   const char *device;
2878
2879   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2880   r = guestfs_tune2fs_l (g, device);
2881   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2882   if (r == NULL) {
2883     throw_exception (env, guestfs_last_error (g));
2884     return NULL;
2885   }
2886   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
2887   return NULL;
2888 }
2889
2890 JNIEXPORT void JNICALL
2891 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
2892   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2893 {
2894   guestfs_h *g = (guestfs_h *) (long) jg;
2895   int r;
2896   const char *device;
2897
2898   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2899   r = guestfs_blockdev_setro (g, device);
2900   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2901   if (r == -1) {
2902     throw_exception (env, guestfs_last_error (g));
2903     return ;
2904   }
2905 }
2906
2907 JNIEXPORT void JNICALL
2908 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
2909   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2910 {
2911   guestfs_h *g = (guestfs_h *) (long) jg;
2912   int r;
2913   const char *device;
2914
2915   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2916   r = guestfs_blockdev_setrw (g, device);
2917   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2918   if (r == -1) {
2919     throw_exception (env, guestfs_last_error (g));
2920     return ;
2921   }
2922 }
2923
2924 JNIEXPORT jboolean JNICALL
2925 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
2926   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2927 {
2928   guestfs_h *g = (guestfs_h *) (long) jg;
2929   int r;
2930   const char *device;
2931
2932   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2933   r = guestfs_blockdev_getro (g, device);
2934   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2935   if (r == -1) {
2936     throw_exception (env, guestfs_last_error (g));
2937     return 0;
2938   }
2939   return (jboolean) r;
2940 }
2941
2942 JNIEXPORT jint JNICALL
2943 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
2944   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2945 {
2946   guestfs_h *g = (guestfs_h *) (long) jg;
2947   int r;
2948   const char *device;
2949
2950   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2951   r = guestfs_blockdev_getss (g, device);
2952   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2953   if (r == -1) {
2954     throw_exception (env, guestfs_last_error (g));
2955     return 0;
2956   }
2957   return (jint) r;
2958 }
2959
2960 JNIEXPORT jint JNICALL
2961 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
2962   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2963 {
2964   guestfs_h *g = (guestfs_h *) (long) jg;
2965   int r;
2966   const char *device;
2967
2968   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2969   r = guestfs_blockdev_getbsz (g, device);
2970   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2971   if (r == -1) {
2972     throw_exception (env, guestfs_last_error (g));
2973     return 0;
2974   }
2975   return (jint) r;
2976 }
2977
2978 JNIEXPORT void JNICALL
2979 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
2980   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
2981 {
2982   guestfs_h *g = (guestfs_h *) (long) jg;
2983   int r;
2984   const char *device;
2985   int blocksize;
2986
2987   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2988   blocksize = jblocksize;
2989   r = guestfs_blockdev_setbsz (g, device, blocksize);
2990   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2991   if (r == -1) {
2992     throw_exception (env, guestfs_last_error (g));
2993     return ;
2994   }
2995 }
2996
2997 JNIEXPORT jlong JNICALL
2998 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
2999   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3000 {
3001   guestfs_h *g = (guestfs_h *) (long) jg;
3002   int64_t r;
3003   const char *device;
3004
3005   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3006   r = guestfs_blockdev_getsz (g, device);
3007   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3008   if (r == -1) {
3009     throw_exception (env, guestfs_last_error (g));
3010     return 0;
3011   }
3012   return (jlong) r;
3013 }
3014
3015 JNIEXPORT jlong JNICALL
3016 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
3017   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3018 {
3019   guestfs_h *g = (guestfs_h *) (long) jg;
3020   int64_t r;
3021   const char *device;
3022
3023   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3024   r = guestfs_blockdev_getsize64 (g, device);
3025   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3026   if (r == -1) {
3027     throw_exception (env, guestfs_last_error (g));
3028     return 0;
3029   }
3030   return (jlong) r;
3031 }
3032
3033 JNIEXPORT void JNICALL
3034 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
3035   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3036 {
3037   guestfs_h *g = (guestfs_h *) (long) jg;
3038   int r;
3039   const char *device;
3040
3041   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3042   r = guestfs_blockdev_flushbufs (g, device);
3043   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3044   if (r == -1) {
3045     throw_exception (env, guestfs_last_error (g));
3046     return ;
3047   }
3048 }
3049
3050 JNIEXPORT void JNICALL
3051 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
3052   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3053 {
3054   guestfs_h *g = (guestfs_h *) (long) jg;
3055   int r;
3056   const char *device;
3057
3058   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3059   r = guestfs_blockdev_rereadpt (g, device);
3060   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3061   if (r == -1) {
3062     throw_exception (env, guestfs_last_error (g));
3063     return ;
3064   }
3065 }
3066
3067 JNIEXPORT void JNICALL
3068 Java_com_redhat_et_libguestfs_GuestFS__1upload
3069   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
3070 {
3071   guestfs_h *g = (guestfs_h *) (long) jg;
3072   int r;
3073   const char *filename;
3074   const char *remotefilename;
3075
3076   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3077   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3078   r = guestfs_upload (g, filename, remotefilename);
3079   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3080   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3081   if (r == -1) {
3082     throw_exception (env, guestfs_last_error (g));
3083     return ;
3084   }
3085 }
3086
3087 JNIEXPORT void JNICALL
3088 Java_com_redhat_et_libguestfs_GuestFS__1download
3089   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
3090 {
3091   guestfs_h *g = (guestfs_h *) (long) jg;
3092   int r;
3093   const char *remotefilename;
3094   const char *filename;
3095
3096   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3097   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3098   r = guestfs_download (g, remotefilename, filename);
3099   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3100   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3101   if (r == -1) {
3102     throw_exception (env, guestfs_last_error (g));
3103     return ;
3104   }
3105 }
3106
3107 JNIEXPORT jstring JNICALL
3108 Java_com_redhat_et_libguestfs_GuestFS__1checksum
3109   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
3110 {
3111   guestfs_h *g = (guestfs_h *) (long) jg;
3112   jstring jr;
3113   char *r;
3114   const char *csumtype;
3115   const char *path;
3116
3117   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
3118   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3119   r = guestfs_checksum (g, csumtype, path);
3120   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
3121   (*env)->ReleaseStringUTFChars (env, jpath, path);
3122   if (r == NULL) {
3123     throw_exception (env, guestfs_last_error (g));
3124     return NULL;
3125   }
3126   jr = (*env)->NewStringUTF (env, r);
3127   free (r);
3128   return jr;
3129 }
3130
3131 JNIEXPORT void JNICALL
3132 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
3133   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
3134 {
3135   guestfs_h *g = (guestfs_h *) (long) jg;
3136   int r;
3137   const char *tarfile;
3138   const char *directory;
3139
3140   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3141   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3142   r = guestfs_tar_in (g, tarfile, directory);
3143   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3144   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3145   if (r == -1) {
3146     throw_exception (env, guestfs_last_error (g));
3147     return ;
3148   }
3149 }
3150
3151 JNIEXPORT void JNICALL
3152 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
3153   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
3154 {
3155   guestfs_h *g = (guestfs_h *) (long) jg;
3156   int r;
3157   const char *directory;
3158   const char *tarfile;
3159
3160   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3161   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3162   r = guestfs_tar_out (g, directory, tarfile);
3163   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3164   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3165   if (r == -1) {
3166     throw_exception (env, guestfs_last_error (g));
3167     return ;
3168   }
3169 }
3170
3171 JNIEXPORT void JNICALL
3172 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
3173   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
3174 {
3175   guestfs_h *g = (guestfs_h *) (long) jg;
3176   int r;
3177   const char *tarball;
3178   const char *directory;
3179
3180   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3181   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3182   r = guestfs_tgz_in (g, tarball, directory);
3183   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3184   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3185   if (r == -1) {
3186     throw_exception (env, guestfs_last_error (g));
3187     return ;
3188   }
3189 }
3190
3191 JNIEXPORT void JNICALL
3192 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
3193   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
3194 {
3195   guestfs_h *g = (guestfs_h *) (long) jg;
3196   int r;
3197   const char *directory;
3198   const char *tarball;
3199
3200   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3201   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3202   r = guestfs_tgz_out (g, directory, tarball);
3203   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3204   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3205   if (r == -1) {
3206     throw_exception (env, guestfs_last_error (g));
3207     return ;
3208   }
3209 }
3210
3211 JNIEXPORT void JNICALL
3212 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
3213   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
3214 {
3215   guestfs_h *g = (guestfs_h *) (long) jg;
3216   int r;
3217   const char *device;
3218   const char *mountpoint;
3219
3220   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3221   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3222   r = guestfs_mount_ro (g, device, mountpoint);
3223   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3224   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3225   if (r == -1) {
3226     throw_exception (env, guestfs_last_error (g));
3227     return ;
3228   }
3229 }
3230
3231 JNIEXPORT void JNICALL
3232 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
3233   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
3234 {
3235   guestfs_h *g = (guestfs_h *) (long) jg;
3236   int r;
3237   const char *options;
3238   const char *device;
3239   const char *mountpoint;
3240
3241   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3242   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3243   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3244   r = guestfs_mount_options (g, options, device, mountpoint);
3245   (*env)->ReleaseStringUTFChars (env, joptions, options);
3246   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3247   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3248   if (r == -1) {
3249     throw_exception (env, guestfs_last_error (g));
3250     return ;
3251   }
3252 }
3253
3254 JNIEXPORT void JNICALL
3255 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
3256   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
3257 {
3258   guestfs_h *g = (guestfs_h *) (long) jg;
3259   int r;
3260   const char *options;
3261   const char *vfstype;
3262   const char *device;
3263   const char *mountpoint;
3264
3265   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3266   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
3267   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3268   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3269   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3270   (*env)->ReleaseStringUTFChars (env, joptions, options);
3271   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
3272   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3273   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3274   if (r == -1) {
3275     throw_exception (env, guestfs_last_error (g));
3276     return ;
3277   }
3278 }
3279
3280 JNIEXPORT jstring JNICALL
3281 Java_com_redhat_et_libguestfs_GuestFS__1debug
3282   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
3283 {
3284   guestfs_h *g = (guestfs_h *) (long) jg;
3285   jstring jr;
3286   char *r;
3287   const char *subcmd;
3288   int extraargs_len;
3289   const char **extraargs;
3290   int i;
3291
3292   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
3293   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
3294   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
3295   for (i = 0; i < extraargs_len; ++i) {
3296     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3297     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
3298   }
3299   extraargs[extraargs_len] = NULL;
3300   r = guestfs_debug (g, subcmd, extraargs);
3301   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
3302   for (i = 0; i < extraargs_len; ++i) {
3303     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3304     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
3305   }
3306   free (extraargs);
3307   if (r == NULL) {
3308     throw_exception (env, guestfs_last_error (g));
3309     return NULL;
3310   }
3311   jr = (*env)->NewStringUTF (env, r);
3312   free (r);
3313   return jr;
3314 }
3315
3316 JNIEXPORT void JNICALL
3317 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
3318   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3319 {
3320   guestfs_h *g = (guestfs_h *) (long) jg;
3321   int r;
3322   const char *device;
3323
3324   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3325   r = guestfs_lvremove (g, device);
3326   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3327   if (r == -1) {
3328     throw_exception (env, guestfs_last_error (g));
3329     return ;
3330   }
3331 }
3332
3333 JNIEXPORT void JNICALL
3334 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
3335   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
3336 {
3337   guestfs_h *g = (guestfs_h *) (long) jg;
3338   int r;
3339   const char *vgname;
3340
3341   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
3342   r = guestfs_vgremove (g, vgname);
3343   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
3344   if (r == -1) {
3345     throw_exception (env, guestfs_last_error (g));
3346     return ;
3347   }
3348 }
3349
3350 JNIEXPORT void JNICALL
3351 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
3352   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3353 {
3354   guestfs_h *g = (guestfs_h *) (long) jg;
3355   int r;
3356   const char *device;
3357
3358   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3359   r = guestfs_pvremove (g, device);
3360   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3361   if (r == -1) {
3362     throw_exception (env, guestfs_last_error (g));
3363     return ;
3364   }
3365 }
3366
3367 JNIEXPORT void JNICALL
3368 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
3369   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
3370 {
3371   guestfs_h *g = (guestfs_h *) (long) jg;
3372   int r;
3373   const char *device;
3374   const char *label;
3375
3376   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3377   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
3378   r = guestfs_set_e2label (g, device, label);
3379   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3380   (*env)->ReleaseStringUTFChars (env, jlabel, label);
3381   if (r == -1) {
3382     throw_exception (env, guestfs_last_error (g));
3383     return ;
3384   }
3385 }
3386
3387 JNIEXPORT jstring JNICALL
3388 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
3389   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3390 {
3391   guestfs_h *g = (guestfs_h *) (long) jg;
3392   jstring jr;
3393   char *r;
3394   const char *device;
3395
3396   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3397   r = guestfs_get_e2label (g, device);
3398   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3399   if (r == NULL) {
3400     throw_exception (env, guestfs_last_error (g));
3401     return NULL;
3402   }
3403   jr = (*env)->NewStringUTF (env, r);
3404   free (r);
3405   return jr;
3406 }
3407
3408 JNIEXPORT void JNICALL
3409 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
3410   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
3411 {
3412   guestfs_h *g = (guestfs_h *) (long) jg;
3413   int r;
3414   const char *device;
3415   const char *uuid;
3416
3417   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3418   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
3419   r = guestfs_set_e2uuid (g, device, uuid);
3420   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3421   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
3422   if (r == -1) {
3423     throw_exception (env, guestfs_last_error (g));
3424     return ;
3425   }
3426 }
3427
3428 JNIEXPORT jstring JNICALL
3429 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
3430   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3431 {
3432   guestfs_h *g = (guestfs_h *) (long) jg;
3433   jstring jr;
3434   char *r;
3435   const char *device;
3436
3437   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3438   r = guestfs_get_e2uuid (g, device);
3439   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3440   if (r == NULL) {
3441     throw_exception (env, guestfs_last_error (g));
3442     return NULL;
3443   }
3444   jr = (*env)->NewStringUTF (env, r);
3445   free (r);
3446   return jr;
3447 }
3448
3449 JNIEXPORT jint JNICALL
3450 Java_com_redhat_et_libguestfs_GuestFS__1fsck
3451   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
3452 {
3453   guestfs_h *g = (guestfs_h *) (long) jg;
3454   int r;
3455   const char *fstype;
3456   const char *device;
3457
3458   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
3459   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3460   r = guestfs_fsck (g, fstype, device);
3461   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
3462   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3463   if (r == -1) {
3464     throw_exception (env, guestfs_last_error (g));
3465     return 0;
3466   }
3467   return (jint) r;
3468 }
3469
3470 JNIEXPORT void JNICALL
3471 Java_com_redhat_et_libguestfs_GuestFS__1zero
3472   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3473 {
3474   guestfs_h *g = (guestfs_h *) (long) jg;
3475   int r;
3476   const char *device;
3477
3478   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3479   r = guestfs_zero (g, device);
3480   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3481   if (r == -1) {
3482     throw_exception (env, guestfs_last_error (g));
3483     return ;
3484   }
3485 }
3486
3487 JNIEXPORT void JNICALL
3488 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
3489   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
3490 {
3491   guestfs_h *g = (guestfs_h *) (long) jg;
3492   int r;
3493   const char *root;
3494   const char *device;
3495
3496   root = (*env)->GetStringUTFChars (env, jroot, NULL);
3497   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3498   r = guestfs_grub_install (g, root, device);
3499   (*env)->ReleaseStringUTFChars (env, jroot, root);
3500   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3501   if (r == -1) {
3502     throw_exception (env, guestfs_last_error (g));
3503     return ;
3504   }
3505 }
3506
3507 JNIEXPORT void JNICALL
3508 Java_com_redhat_et_libguestfs_GuestFS__1cp
3509   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3510 {
3511   guestfs_h *g = (guestfs_h *) (long) jg;
3512   int r;
3513   const char *src;
3514   const char *dest;
3515
3516   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3517   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3518   r = guestfs_cp (g, src, dest);
3519   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3520   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3521   if (r == -1) {
3522     throw_exception (env, guestfs_last_error (g));
3523     return ;
3524   }
3525 }
3526
3527 JNIEXPORT void JNICALL
3528 Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
3529   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3530 {
3531   guestfs_h *g = (guestfs_h *) (long) jg;
3532   int r;
3533   const char *src;
3534   const char *dest;
3535
3536   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3537   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3538   r = guestfs_cp_a (g, src, dest);
3539   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3540   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3541   if (r == -1) {
3542     throw_exception (env, guestfs_last_error (g));
3543     return ;
3544   }
3545 }
3546
3547 JNIEXPORT void JNICALL
3548 Java_com_redhat_et_libguestfs_GuestFS__1mv
3549   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3550 {
3551   guestfs_h *g = (guestfs_h *) (long) jg;
3552   int r;
3553   const char *src;
3554   const char *dest;
3555
3556   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3557   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3558   r = guestfs_mv (g, src, dest);
3559   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3560   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3561   if (r == -1) {
3562     throw_exception (env, guestfs_last_error (g));
3563     return ;
3564   }
3565 }
3566
3567 JNIEXPORT void JNICALL
3568 Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
3569   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
3570 {
3571   guestfs_h *g = (guestfs_h *) (long) jg;
3572   int r;
3573   int whattodrop;
3574
3575   whattodrop = jwhattodrop;
3576   r = guestfs_drop_caches (g, whattodrop);
3577   if (r == -1) {
3578     throw_exception (env, guestfs_last_error (g));
3579     return ;
3580   }
3581 }
3582
3583 JNIEXPORT jstring JNICALL
3584 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
3585   (JNIEnv *env, jobject obj, jlong jg)
3586 {
3587   guestfs_h *g = (guestfs_h *) (long) jg;
3588   jstring jr;
3589   char *r;
3590
3591   r = guestfs_dmesg (g);
3592   if (r == NULL) {
3593     throw_exception (env, guestfs_last_error (g));
3594     return NULL;
3595   }
3596   jr = (*env)->NewStringUTF (env, r);
3597   free (r);
3598   return jr;
3599 }
3600
3601 JNIEXPORT void JNICALL
3602 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
3603   (JNIEnv *env, jobject obj, jlong jg)
3604 {
3605   guestfs_h *g = (guestfs_h *) (long) jg;
3606   int r;
3607
3608   r = guestfs_ping_daemon (g);
3609   if (r == -1) {
3610     throw_exception (env, guestfs_last_error (g));
3611     return ;
3612   }
3613 }
3614
3615 JNIEXPORT jboolean JNICALL
3616 Java_com_redhat_et_libguestfs_GuestFS__1equal
3617   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
3618 {
3619   guestfs_h *g = (guestfs_h *) (long) jg;
3620   int r;
3621   const char *file1;
3622   const char *file2;
3623
3624   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
3625   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
3626   r = guestfs_equal (g, file1, file2);
3627   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
3628   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
3629   if (r == -1) {
3630     throw_exception (env, guestfs_last_error (g));
3631     return 0;
3632   }
3633   return (jboolean) r;
3634 }
3635
3636 JNIEXPORT jobjectArray JNICALL
3637 Java_com_redhat_et_libguestfs_GuestFS__1strings
3638   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3639 {
3640   guestfs_h *g = (guestfs_h *) (long) jg;
3641   jobjectArray jr;
3642   int r_len;
3643   jclass cl;
3644   jstring jstr;
3645   char **r;
3646   const char *path;
3647   int i;
3648
3649   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3650   r = guestfs_strings (g, path);
3651   (*env)->ReleaseStringUTFChars (env, jpath, path);
3652   if (r == NULL) {
3653     throw_exception (env, guestfs_last_error (g));
3654     return NULL;
3655   }
3656   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3657   cl = (*env)->FindClass (env, "java/lang/String");
3658   jstr = (*env)->NewStringUTF (env, "");
3659   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3660   for (i = 0; i < r_len; ++i) {
3661     jstr = (*env)->NewStringUTF (env, r[i]);
3662     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3663     free (r[i]);
3664   }
3665   free (r);
3666   return jr;
3667 }
3668
3669 JNIEXPORT jobjectArray JNICALL
3670 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
3671   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
3672 {
3673   guestfs_h *g = (guestfs_h *) (long) jg;
3674   jobjectArray jr;
3675   int r_len;
3676   jclass cl;
3677   jstring jstr;
3678   char **r;
3679   const char *encoding;
3680   const char *path;
3681   int i;
3682
3683   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
3684   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3685   r = guestfs_strings_e (g, encoding, path);
3686   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
3687   (*env)->ReleaseStringUTFChars (env, jpath, path);
3688   if (r == NULL) {
3689     throw_exception (env, guestfs_last_error (g));
3690     return NULL;
3691   }
3692   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3693   cl = (*env)->FindClass (env, "java/lang/String");
3694   jstr = (*env)->NewStringUTF (env, "");
3695   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3696   for (i = 0; i < r_len; ++i) {
3697     jstr = (*env)->NewStringUTF (env, r[i]);
3698     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3699     free (r[i]);
3700   }
3701   free (r);
3702   return jr;
3703 }
3704
3705 JNIEXPORT jstring JNICALL
3706 Java_com_redhat_et_libguestfs_GuestFS__1hexdump
3707   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3708 {
3709   guestfs_h *g = (guestfs_h *) (long) jg;
3710   jstring jr;
3711   char *r;
3712   const char *path;
3713
3714   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3715   r = guestfs_hexdump (g, path);
3716   (*env)->ReleaseStringUTFChars (env, jpath, path);
3717   if (r == NULL) {
3718     throw_exception (env, guestfs_last_error (g));
3719     return NULL;
3720   }
3721   jr = (*env)->NewStringUTF (env, r);
3722   free (r);
3723   return jr;
3724 }
3725
3726 JNIEXPORT void JNICALL
3727 Java_com_redhat_et_libguestfs_GuestFS__1zerofree
3728   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3729 {
3730   guestfs_h *g = (guestfs_h *) (long) jg;
3731   int r;
3732   const char *device;
3733
3734   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3735   r = guestfs_zerofree (g, device);
3736   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3737   if (r == -1) {
3738     throw_exception (env, guestfs_last_error (g));
3739     return ;
3740   }
3741 }
3742
3743 JNIEXPORT void JNICALL
3744 Java_com_redhat_et_libguestfs_GuestFS__1pvresize
3745   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3746 {
3747   guestfs_h *g = (guestfs_h *) (long) jg;
3748   int r;
3749   const char *device;
3750
3751   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3752   r = guestfs_pvresize (g, device);
3753   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3754   if (r == -1) {
3755     throw_exception (env, guestfs_last_error (g));
3756     return ;
3757   }
3758 }
3759
3760 JNIEXPORT void JNICALL
3761 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1N
3762   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jpartnum, jint jcyls, jint jheads, jint jsectors, jstring jline)
3763 {
3764   guestfs_h *g = (guestfs_h *) (long) jg;
3765   int r;
3766   const char *device;
3767   int partnum;
3768   int cyls;
3769   int heads;
3770   int sectors;
3771   const char *line;
3772
3773   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3774   partnum = jpartnum;
3775   cyls = jcyls;
3776   heads = jheads;
3777   sectors = jsectors;
3778   line = (*env)->GetStringUTFChars (env, jline, NULL);
3779   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
3780   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3781   (*env)->ReleaseStringUTFChars (env, jline, line);
3782   if (r == -1) {
3783     throw_exception (env, guestfs_last_error (g));
3784     return ;
3785   }
3786 }
3787
3788 JNIEXPORT jstring JNICALL
3789 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1l
3790   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3791 {
3792   guestfs_h *g = (guestfs_h *) (long) jg;
3793   jstring jr;
3794   char *r;
3795   const char *device;
3796
3797   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3798   r = guestfs_sfdisk_l (g, device);
3799   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3800   if (r == NULL) {
3801     throw_exception (env, guestfs_last_error (g));
3802     return NULL;
3803   }
3804   jr = (*env)->NewStringUTF (env, r);
3805   free (r);
3806   return jr;
3807 }
3808
3809 JNIEXPORT jstring JNICALL
3810 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1kernel_1geometry
3811   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3812 {
3813   guestfs_h *g = (guestfs_h *) (long) jg;
3814   jstring jr;
3815   char *r;
3816   const char *device;
3817
3818   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3819   r = guestfs_sfdisk_kernel_geometry (g, device);
3820   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3821   if (r == NULL) {
3822     throw_exception (env, guestfs_last_error (g));
3823     return NULL;
3824   }
3825   jr = (*env)->NewStringUTF (env, r);
3826   free (r);
3827   return jr;
3828 }
3829
3830 JNIEXPORT jstring JNICALL
3831 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1disk_1geometry
3832   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3833 {
3834   guestfs_h *g = (guestfs_h *) (long) jg;
3835   jstring jr;
3836   char *r;
3837   const char *device;
3838
3839   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3840   r = guestfs_sfdisk_disk_geometry (g, device);
3841   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3842   if (r == NULL) {
3843     throw_exception (env, guestfs_last_error (g));
3844     return NULL;
3845   }
3846   jr = (*env)->NewStringUTF (env, r);
3847   free (r);
3848   return jr;
3849 }
3850
3851 JNIEXPORT void JNICALL
3852 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate_1all
3853   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate)
3854 {
3855   guestfs_h *g = (guestfs_h *) (long) jg;
3856   int r;
3857   int activate;
3858
3859   activate = jactivate;
3860   r = guestfs_vg_activate_all (g, activate);
3861   if (r == -1) {
3862     throw_exception (env, guestfs_last_error (g));
3863     return ;
3864   }
3865 }
3866
3867 JNIEXPORT void JNICALL
3868 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate
3869   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate, jobjectArray jvolgroups)
3870 {
3871   guestfs_h *g = (guestfs_h *) (long) jg;
3872   int r;
3873   int activate;
3874   int volgroups_len;
3875   const char **volgroups;
3876   int i;
3877
3878   activate = jactivate;
3879   volgroups_len = (*env)->GetArrayLength (env, jvolgroups);
3880   volgroups = guestfs_safe_malloc (g, sizeof (char *) * (volgroups_len+1));
3881   for (i = 0; i < volgroups_len; ++i) {
3882     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3883     volgroups[i] = (*env)->GetStringUTFChars (env, o, NULL);
3884   }
3885   volgroups[volgroups_len] = NULL;
3886   r = guestfs_vg_activate (g, activate, volgroups);
3887   for (i = 0; i < volgroups_len; ++i) {
3888     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3889     (*env)->ReleaseStringUTFChars (env, o, volgroups[i]);
3890   }
3891   free (volgroups);
3892   if (r == -1) {
3893     throw_exception (env, guestfs_last_error (g));
3894     return ;
3895   }
3896 }
3897
3898 JNIEXPORT void JNICALL
3899 Java_com_redhat_et_libguestfs_GuestFS__1lvresize
3900   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jmbytes)
3901 {
3902   guestfs_h *g = (guestfs_h *) (long) jg;
3903   int r;
3904   const char *device;
3905   int mbytes;
3906
3907   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3908   mbytes = jmbytes;
3909   r = guestfs_lvresize (g, device, mbytes);
3910   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3911   if (r == -1) {
3912     throw_exception (env, guestfs_last_error (g));
3913     return ;
3914   }
3915 }
3916
3917 JNIEXPORT void JNICALL
3918 Java_com_redhat_et_libguestfs_GuestFS__1resize2fs
3919   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3920 {
3921   guestfs_h *g = (guestfs_h *) (long) jg;
3922   int r;
3923   const char *device;
3924
3925   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3926   r = guestfs_resize2fs (g, device);
3927   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3928   if (r == -1) {
3929     throw_exception (env, guestfs_last_error (g));
3930     return ;
3931   }
3932 }
3933
3934 JNIEXPORT jobjectArray JNICALL
3935 Java_com_redhat_et_libguestfs_GuestFS__1find
3936   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
3937 {
3938   guestfs_h *g = (guestfs_h *) (long) jg;
3939   jobjectArray jr;
3940   int r_len;
3941   jclass cl;
3942   jstring jstr;
3943   char **r;
3944   const char *directory;
3945   int i;
3946
3947   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3948   r = guestfs_find (g, directory);
3949   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3950   if (r == NULL) {
3951     throw_exception (env, guestfs_last_error (g));
3952     return NULL;
3953   }
3954   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3955   cl = (*env)->FindClass (env, "java/lang/String");
3956   jstr = (*env)->NewStringUTF (env, "");
3957   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3958   for (i = 0; i < r_len; ++i) {
3959     jstr = (*env)->NewStringUTF (env, r[i]);
3960     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3961     free (r[i]);
3962   }
3963   free (r);
3964   return jr;
3965 }
3966
3967 JNIEXPORT void JNICALL
3968 Java_com_redhat_et_libguestfs_GuestFS__1e2fsck_1f
3969   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3970 {
3971   guestfs_h *g = (guestfs_h *) (long) jg;
3972   int r;
3973   const char *device;
3974
3975   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3976   r = guestfs_e2fsck_f (g, device);
3977   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3978   if (r == -1) {
3979     throw_exception (env, guestfs_last_error (g));
3980     return ;
3981   }
3982 }
3983
3984 JNIEXPORT void JNICALL
3985 Java_com_redhat_et_libguestfs_GuestFS__1sleep
3986   (JNIEnv *env, jobject obj, jlong jg, jint jsecs)
3987 {
3988   guestfs_h *g = (guestfs_h *) (long) jg;
3989   int r;
3990   int secs;
3991
3992   secs = jsecs;
3993   r = guestfs_sleep (g, secs);
3994   if (r == -1) {
3995     throw_exception (env, guestfs_last_error (g));
3996     return ;
3997   }
3998 }
3999
4000 JNIEXPORT jint JNICALL
4001 Java_com_redhat_et_libguestfs_GuestFS__1ntfs_13g_1probe
4002   (JNIEnv *env, jobject obj, jlong jg, jboolean jrw, jstring jdevice)
4003 {
4004   guestfs_h *g = (guestfs_h *) (long) jg;
4005   int r;
4006   int rw;
4007   const char *device;
4008
4009   rw = jrw;
4010   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4011   r = guestfs_ntfs_3g_probe (g, rw, device);
4012   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4013   if (r == -1) {
4014     throw_exception (env, guestfs_last_error (g));
4015     return 0;
4016   }
4017   return (jint) r;
4018 }
4019
4020 JNIEXPORT jstring JNICALL
4021 Java_com_redhat_et_libguestfs_GuestFS__1sh
4022   (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
4023 {
4024   guestfs_h *g = (guestfs_h *) (long) jg;
4025   jstring jr;
4026   char *r;
4027   const char *command;
4028
4029   command = (*env)->GetStringUTFChars (env, jcommand, NULL);
4030   r = guestfs_sh (g, command);
4031   (*env)->ReleaseStringUTFChars (env, jcommand, command);
4032   if (r == NULL) {
4033     throw_exception (env, guestfs_last_error (g));
4034     return NULL;
4035   }
4036   jr = (*env)->NewStringUTF (env, r);
4037   free (r);
4038   return jr;
4039 }
4040
4041 JNIEXPORT jobjectArray JNICALL
4042 Java_com_redhat_et_libguestfs_GuestFS__1sh_1lines
4043   (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
4044 {
4045   guestfs_h *g = (guestfs_h *) (long) jg;
4046   jobjectArray jr;
4047   int r_len;
4048   jclass cl;
4049   jstring jstr;
4050   char **r;
4051   const char *command;
4052   int i;
4053
4054   command = (*env)->GetStringUTFChars (env, jcommand, NULL);
4055   r = guestfs_sh_lines (g, command);
4056   (*env)->ReleaseStringUTFChars (env, jcommand, command);
4057   if (r == NULL) {
4058     throw_exception (env, guestfs_last_error (g));
4059     return NULL;
4060   }
4061   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4062   cl = (*env)->FindClass (env, "java/lang/String");
4063   jstr = (*env)->NewStringUTF (env, "");
4064   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4065   for (i = 0; i < r_len; ++i) {
4066     jstr = (*env)->NewStringUTF (env, r[i]);
4067     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4068     free (r[i]);
4069   }
4070   free (r);
4071   return jr;
4072 }
4073
4074 JNIEXPORT jobjectArray JNICALL
4075 Java_com_redhat_et_libguestfs_GuestFS__1glob_1expand
4076   (JNIEnv *env, jobject obj, jlong jg, jstring jpattern)
4077 {
4078   guestfs_h *g = (guestfs_h *) (long) jg;
4079   jobjectArray jr;
4080   int r_len;
4081   jclass cl;
4082   jstring jstr;
4083   char **r;
4084   const char *pattern;
4085   int i;
4086
4087   pattern = (*env)->GetStringUTFChars (env, jpattern, NULL);
4088   r = guestfs_glob_expand (g, pattern);
4089   (*env)->ReleaseStringUTFChars (env, jpattern, pattern);
4090   if (r == NULL) {
4091     throw_exception (env, guestfs_last_error (g));
4092     return NULL;
4093   }
4094   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4095   cl = (*env)->FindClass (env, "java/lang/String");
4096   jstr = (*env)->NewStringUTF (env, "");
4097   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4098   for (i = 0; i < r_len; ++i) {
4099     jstr = (*env)->NewStringUTF (env, r[i]);
4100     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4101     free (r[i]);
4102   }
4103   free (r);
4104   return jr;
4105 }
4106
4107 JNIEXPORT void JNICALL
4108 Java_com_redhat_et_libguestfs_GuestFS__1scrub_1device
4109   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
4110 {
4111   guestfs_h *g = (guestfs_h *) (long) jg;
4112   int r;
4113   const char *device;
4114
4115   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4116   r = guestfs_scrub_device (g, device);
4117   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4118   if (r == -1) {
4119     throw_exception (env, guestfs_last_error (g));
4120     return ;
4121   }
4122 }
4123
4124 JNIEXPORT void JNICALL
4125 Java_com_redhat_et_libguestfs_GuestFS__1scrub_1file
4126   (JNIEnv *env, jobject obj, jlong jg, jstring jfile)
4127 {
4128   guestfs_h *g = (guestfs_h *) (long) jg;
4129   int r;
4130   const char *file;
4131
4132   file = (*env)->GetStringUTFChars (env, jfile, NULL);
4133   r = guestfs_scrub_file (g, file);
4134   (*env)->ReleaseStringUTFChars (env, jfile, file);
4135   if (r == -1) {
4136     throw_exception (env, guestfs_last_error (g));
4137     return ;
4138   }
4139 }
4140
4141 JNIEXPORT void JNICALL
4142 Java_com_redhat_et_libguestfs_GuestFS__1scrub_1freespace
4143   (JNIEnv *env, jobject obj, jlong jg, jstring jdir)
4144 {
4145   guestfs_h *g = (guestfs_h *) (long) jg;
4146   int r;
4147   const char *dir;
4148
4149   dir = (*env)->GetStringUTFChars (env, jdir, NULL);
4150   r = guestfs_scrub_freespace (g, dir);
4151   (*env)->ReleaseStringUTFChars (env, jdir, dir);
4152   if (r == -1) {
4153     throw_exception (env, guestfs_last_error (g));
4154     return ;
4155   }
4156 }
4157
4158 JNIEXPORT jstring JNICALL
4159 Java_com_redhat_et_libguestfs_GuestFS__1mkdtemp
4160   (JNIEnv *env, jobject obj, jlong jg, jstring jtemplate)
4161 {
4162   guestfs_h *g = (guestfs_h *) (long) jg;
4163   jstring jr;
4164   char *r;
4165   const char *template;
4166
4167   template = (*env)->GetStringUTFChars (env, jtemplate, NULL);
4168   r = guestfs_mkdtemp (g, template);
4169   (*env)->ReleaseStringUTFChars (env, jtemplate, template);
4170   if (r == NULL) {
4171     throw_exception (env, guestfs_last_error (g));
4172     return NULL;
4173   }
4174   jr = (*env)->NewStringUTF (env, r);
4175   free (r);
4176   return jr;
4177 }
4178
4179 JNIEXPORT jint JNICALL
4180 Java_com_redhat_et_libguestfs_GuestFS__1wc_1l
4181   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4182 {
4183   guestfs_h *g = (guestfs_h *) (long) jg;
4184   int r;
4185   const char *path;
4186
4187   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4188   r = guestfs_wc_l (g, path);
4189   (*env)->ReleaseStringUTFChars (env, jpath, path);
4190   if (r == -1) {
4191     throw_exception (env, guestfs_last_error (g));
4192     return 0;
4193   }
4194   return (jint) r;
4195 }
4196
4197 JNIEXPORT jint JNICALL
4198 Java_com_redhat_et_libguestfs_GuestFS__1wc_1w
4199   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4200 {
4201   guestfs_h *g = (guestfs_h *) (long) jg;
4202   int r;
4203   const char *path;
4204
4205   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4206   r = guestfs_wc_w (g, path);
4207   (*env)->ReleaseStringUTFChars (env, jpath, path);
4208   if (r == -1) {
4209     throw_exception (env, guestfs_last_error (g));
4210     return 0;
4211   }
4212   return (jint) r;
4213 }
4214
4215 JNIEXPORT jint JNICALL
4216 Java_com_redhat_et_libguestfs_GuestFS__1wc_1c
4217   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4218 {
4219   guestfs_h *g = (guestfs_h *) (long) jg;
4220   int r;
4221   const char *path;
4222
4223   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4224   r = guestfs_wc_c (g, path);
4225   (*env)->ReleaseStringUTFChars (env, jpath, path);
4226   if (r == -1) {
4227     throw_exception (env, guestfs_last_error (g));
4228     return 0;
4229   }
4230   return (jint) r;
4231 }
4232
4233 JNIEXPORT jobjectArray JNICALL
4234 Java_com_redhat_et_libguestfs_GuestFS__1head
4235   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4236 {
4237   guestfs_h *g = (guestfs_h *) (long) jg;
4238   jobjectArray jr;
4239   int r_len;
4240   jclass cl;
4241   jstring jstr;
4242   char **r;
4243   const char *path;
4244   int i;
4245
4246   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4247   r = guestfs_head (g, path);
4248   (*env)->ReleaseStringUTFChars (env, jpath, path);
4249   if (r == NULL) {
4250     throw_exception (env, guestfs_last_error (g));
4251     return NULL;
4252   }
4253   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4254   cl = (*env)->FindClass (env, "java/lang/String");
4255   jstr = (*env)->NewStringUTF (env, "");
4256   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4257   for (i = 0; i < r_len; ++i) {
4258     jstr = (*env)->NewStringUTF (env, r[i]);
4259     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4260     free (r[i]);
4261   }
4262   free (r);
4263   return jr;
4264 }
4265
4266 JNIEXPORT jobjectArray JNICALL
4267 Java_com_redhat_et_libguestfs_GuestFS__1head_1n
4268   (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
4269 {
4270   guestfs_h *g = (guestfs_h *) (long) jg;
4271   jobjectArray jr;
4272   int r_len;
4273   jclass cl;
4274   jstring jstr;
4275   char **r;
4276   int nrlines;
4277   const char *path;
4278   int i;
4279
4280   nrlines = jnrlines;
4281   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4282   r = guestfs_head_n (g, nrlines, path);
4283   (*env)->ReleaseStringUTFChars (env, jpath, path);
4284   if (r == NULL) {
4285     throw_exception (env, guestfs_last_error (g));
4286     return NULL;
4287   }
4288   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4289   cl = (*env)->FindClass (env, "java/lang/String");
4290   jstr = (*env)->NewStringUTF (env, "");
4291   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4292   for (i = 0; i < r_len; ++i) {
4293     jstr = (*env)->NewStringUTF (env, r[i]);
4294     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4295     free (r[i]);
4296   }
4297   free (r);
4298   return jr;
4299 }
4300
4301 JNIEXPORT jobjectArray JNICALL
4302 Java_com_redhat_et_libguestfs_GuestFS__1tail
4303   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4304 {
4305   guestfs_h *g = (guestfs_h *) (long) jg;
4306   jobjectArray jr;
4307   int r_len;
4308   jclass cl;
4309   jstring jstr;
4310   char **r;
4311   const char *path;
4312   int i;
4313
4314   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4315   r = guestfs_tail (g, path);
4316   (*env)->ReleaseStringUTFChars (env, jpath, path);
4317   if (r == NULL) {
4318     throw_exception (env, guestfs_last_error (g));
4319     return NULL;
4320   }
4321   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4322   cl = (*env)->FindClass (env, "java/lang/String");
4323   jstr = (*env)->NewStringUTF (env, "");
4324   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4325   for (i = 0; i < r_len; ++i) {
4326     jstr = (*env)->NewStringUTF (env, r[i]);
4327     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4328     free (r[i]);
4329   }
4330   free (r);
4331   return jr;
4332 }
4333
4334 JNIEXPORT jobjectArray JNICALL
4335 Java_com_redhat_et_libguestfs_GuestFS__1tail_1n
4336   (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
4337 {
4338   guestfs_h *g = (guestfs_h *) (long) jg;
4339   jobjectArray jr;
4340   int r_len;
4341   jclass cl;
4342   jstring jstr;
4343   char **r;
4344   int nrlines;
4345   const char *path;
4346   int i;
4347
4348   nrlines = jnrlines;
4349   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4350   r = guestfs_tail_n (g, nrlines, path);
4351   (*env)->ReleaseStringUTFChars (env, jpath, path);
4352   if (r == NULL) {
4353     throw_exception (env, guestfs_last_error (g));
4354     return NULL;
4355   }
4356   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4357   cl = (*env)->FindClass (env, "java/lang/String");
4358   jstr = (*env)->NewStringUTF (env, "");
4359   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4360   for (i = 0; i < r_len; ++i) {
4361     jstr = (*env)->NewStringUTF (env, r[i]);
4362     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4363     free (r[i]);
4364   }
4365   free (r);
4366   return jr;
4367 }
4368
4369 JNIEXPORT jstring JNICALL
4370 Java_com_redhat_et_libguestfs_GuestFS__1df
4371   (JNIEnv *env, jobject obj, jlong jg)
4372 {
4373   guestfs_h *g = (guestfs_h *) (long) jg;
4374   jstring jr;
4375   char *r;
4376
4377   r = guestfs_df (g);
4378   if (r == NULL) {
4379     throw_exception (env, guestfs_last_error (g));
4380     return NULL;
4381   }
4382   jr = (*env)->NewStringUTF (env, r);
4383   free (r);
4384   return jr;
4385 }
4386
4387 JNIEXPORT jstring JNICALL
4388 Java_com_redhat_et_libguestfs_GuestFS__1df_1h
4389   (JNIEnv *env, jobject obj, jlong jg)
4390 {
4391   guestfs_h *g = (guestfs_h *) (long) jg;
4392   jstring jr;
4393   char *r;
4394
4395   r = guestfs_df_h (g);
4396   if (r == NULL) {
4397     throw_exception (env, guestfs_last_error (g));
4398     return NULL;
4399   }
4400   jr = (*env)->NewStringUTF (env, r);
4401   free (r);
4402   return jr;
4403 }
4404
4405 JNIEXPORT jlong JNICALL
4406 Java_com_redhat_et_libguestfs_GuestFS__1du
4407   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4408 {
4409   guestfs_h *g = (guestfs_h *) (long) jg;
4410   int64_t r;
4411   const char *path;
4412
4413   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4414   r = guestfs_du (g, path);
4415   (*env)->ReleaseStringUTFChars (env, jpath, path);
4416   if (r == -1) {
4417     throw_exception (env, guestfs_last_error (g));
4418     return 0;
4419   }
4420   return (jlong) r;
4421 }
4422
4423 JNIEXPORT jobjectArray JNICALL
4424 Java_com_redhat_et_libguestfs_GuestFS__1initrd_1list
4425   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4426 {
4427   guestfs_h *g = (guestfs_h *) (long) jg;
4428   jobjectArray jr;
4429   int r_len;
4430   jclass cl;
4431   jstring jstr;
4432   char **r;
4433   const char *path;
4434   int i;
4435
4436   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4437   r = guestfs_initrd_list (g, path);
4438   (*env)->ReleaseStringUTFChars (env, jpath, path);
4439   if (r == NULL) {
4440     throw_exception (env, guestfs_last_error (g));
4441     return NULL;
4442   }
4443   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4444   cl = (*env)->FindClass (env, "java/lang/String");
4445   jstr = (*env)->NewStringUTF (env, "");
4446   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4447   for (i = 0; i < r_len; ++i) {
4448     jstr = (*env)->NewStringUTF (env, r[i]);
4449     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4450     free (r[i]);
4451   }
4452   free (r);
4453   return jr;
4454 }
4455
4456 JNIEXPORT void JNICALL
4457 Java_com_redhat_et_libguestfs_GuestFS__1mount_1loop
4458   (JNIEnv *env, jobject obj, jlong jg, jstring jfile, jstring jmountpoint)
4459 {
4460   guestfs_h *g = (guestfs_h *) (long) jg;
4461   int r;
4462   const char *file;
4463   const char *mountpoint;
4464
4465   file = (*env)->GetStringUTFChars (env, jfile, NULL);
4466   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
4467   r = guestfs_mount_loop (g, file, mountpoint);
4468   (*env)->ReleaseStringUTFChars (env, jfile, file);
4469   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
4470   if (r == -1) {
4471     throw_exception (env, guestfs_last_error (g));
4472     return ;
4473   }
4474 }
4475
4476 JNIEXPORT void JNICALL
4477 Java_com_redhat_et_libguestfs_GuestFS__1mkswap
4478   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
4479 {
4480   guestfs_h *g = (guestfs_h *) (long) jg;
4481   int r;
4482   const char *device;
4483
4484   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4485   r = guestfs_mkswap (g, device);
4486   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4487   if (r == -1) {
4488     throw_exception (env, guestfs_last_error (g));
4489     return ;
4490   }
4491 }
4492
4493 JNIEXPORT void JNICALL
4494 Java_com_redhat_et_libguestfs_GuestFS__1mkswap_1L
4495   (JNIEnv *env, jobject obj, jlong jg, jstring jlabel, jstring jdevice)
4496 {
4497   guestfs_h *g = (guestfs_h *) (long) jg;
4498   int r;
4499   const char *label;
4500   const char *device;
4501
4502   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
4503   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4504   r = guestfs_mkswap_L (g, label, device);
4505   (*env)->ReleaseStringUTFChars (env, jlabel, label);
4506   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4507   if (r == -1) {
4508     throw_exception (env, guestfs_last_error (g));
4509     return ;
4510   }
4511 }
4512
4513 JNIEXPORT void JNICALL
4514 Java_com_redhat_et_libguestfs_GuestFS__1mkswap_1U
4515   (JNIEnv *env, jobject obj, jlong jg, jstring juuid, jstring jdevice)
4516 {
4517   guestfs_h *g = (guestfs_h *) (long) jg;
4518   int r;
4519   const char *uuid;
4520   const char *device;
4521
4522   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
4523   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4524   r = guestfs_mkswap_U (g, uuid, device);
4525   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
4526   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4527   if (r == -1) {
4528     throw_exception (env, guestfs_last_error (g));
4529     return ;
4530   }
4531 }
4532
4533 JNIEXPORT void JNICALL
4534 Java_com_redhat_et_libguestfs_GuestFS__1mknod
4535   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jint jdevmajor, jint jdevminor, jstring jpath)
4536 {
4537   guestfs_h *g = (guestfs_h *) (long) jg;
4538   int r;
4539   int mode;
4540   int devmajor;
4541   int devminor;
4542   const char *path;
4543
4544   mode = jmode;
4545   devmajor = jdevmajor;
4546   devminor = jdevminor;
4547   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4548   r = guestfs_mknod (g, mode, devmajor, devminor, path);
4549   (*env)->ReleaseStringUTFChars (env, jpath, path);
4550   if (r == -1) {
4551     throw_exception (env, guestfs_last_error (g));
4552     return ;
4553   }
4554 }
4555
4556 JNIEXPORT void JNICALL
4557 Java_com_redhat_et_libguestfs_GuestFS__1mkfifo
4558   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
4559 {
4560   guestfs_h *g = (guestfs_h *) (long) jg;
4561   int r;
4562   int mode;
4563   const char *path;
4564
4565   mode = jmode;
4566   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4567   r = guestfs_mkfifo (g, mode, path);
4568   (*env)->ReleaseStringUTFChars (env, jpath, path);
4569   if (r == -1) {
4570     throw_exception (env, guestfs_last_error (g));
4571     return ;
4572   }
4573 }
4574
4575 JNIEXPORT void JNICALL
4576 Java_com_redhat_et_libguestfs_GuestFS__1mknod_1b
4577   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jint jdevmajor, jint jdevminor, jstring jpath)
4578 {
4579   guestfs_h *g = (guestfs_h *) (long) jg;
4580   int r;
4581   int mode;
4582   int devmajor;
4583   int devminor;
4584   const char *path;
4585
4586   mode = jmode;
4587   devmajor = jdevmajor;
4588   devminor = jdevminor;
4589   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4590   r = guestfs_mknod_b (g, mode, devmajor, devminor, path);
4591   (*env)->ReleaseStringUTFChars (env, jpath, path);
4592   if (r == -1) {
4593     throw_exception (env, guestfs_last_error (g));
4594     return ;
4595   }
4596 }
4597
4598 JNIEXPORT void JNICALL
4599 Java_com_redhat_et_libguestfs_GuestFS__1mknod_1c
4600   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jint jdevmajor, jint jdevminor, jstring jpath)
4601 {
4602   guestfs_h *g = (guestfs_h *) (long) jg;
4603   int r;
4604   int mode;
4605   int devmajor;
4606   int devminor;
4607   const char *path;
4608
4609   mode = jmode;
4610   devmajor = jdevmajor;
4611   devminor = jdevminor;
4612   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4613   r = guestfs_mknod_c (g, mode, devmajor, devminor, path);
4614   (*env)->ReleaseStringUTFChars (env, jpath, path);
4615   if (r == -1) {
4616     throw_exception (env, guestfs_last_error (g));
4617     return ;
4618   }
4619 }
4620
4621 JNIEXPORT jint JNICALL
4622 Java_com_redhat_et_libguestfs_GuestFS__1umask
4623   (JNIEnv *env, jobject obj, jlong jg, jint jmask)
4624 {
4625   guestfs_h *g = (guestfs_h *) (long) jg;
4626   int r;
4627   int mask;
4628
4629   mask = jmask;
4630   r = guestfs_umask (g, mask);
4631   if (r == -1) {
4632     throw_exception (env, guestfs_last_error (g));
4633     return 0;
4634   }
4635   return (jint) r;
4636 }
4637
4638 JNIEXPORT jobjectArray JNICALL
4639 Java_com_redhat_et_libguestfs_GuestFS__1readdir
4640   (JNIEnv *env, jobject obj, jlong jg, jstring jdir)
4641 {
4642   guestfs_h *g = (guestfs_h *) (long) jg;
4643   jobjectArray jr;
4644   jclass cl;
4645   jfieldID fl;
4646   jobject jfl;
4647   struct guestfs_dirent_list *r;
4648   const char *dir;
4649   int i;
4650
4651   dir = (*env)->GetStringUTFChars (env, jdir, NULL);
4652   r = guestfs_readdir (g, dir);
4653   (*env)->ReleaseStringUTFChars (env, jdir, dir);
4654   if (r == NULL) {
4655     throw_exception (env, guestfs_last_error (g));
4656     return NULL;
4657   }
4658   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Dirent");
4659   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
4660   for (i = 0; i < r->len; ++i) {
4661     jfl = (*env)->AllocObject (env, cl);
4662     fl = (*env)->GetFieldID (env, cl, "ino", "J");
4663     (*env)->SetLongField (env, jfl, fl, r->val[i].ino);
4664     fl = (*env)->GetFieldID (env, cl, "ftyp", "J");
4665     (*env)->SetLongField (env, jfl, fl, r->val[i].ftyp);
4666     fl = (*env)->GetFieldID (env, cl, "name", "Ljava/lang/String;");
4667     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].name));
4668     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
4669   }
4670   guestfs_free_dirent_list (r);
4671   return jr;
4672 }
4673