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__1mount
1406   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
1407 {
1408   guestfs_h *g = (guestfs_h *) (long) jg;
1409   int r;
1410   const char *device;
1411   const char *mountpoint;
1412
1413   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1414   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
1415   r = guestfs_mount (g, device, mountpoint);
1416   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1417   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
1418   if (r == -1) {
1419     throw_exception (env, guestfs_last_error (g));
1420     return ;
1421   }
1422 }
1423
1424 JNIEXPORT void JNICALL
1425 Java_com_redhat_et_libguestfs_GuestFS__1sync
1426   (JNIEnv *env, jobject obj, jlong jg)
1427 {
1428   guestfs_h *g = (guestfs_h *) (long) jg;
1429   int r;
1430
1431   r = guestfs_sync (g);
1432   if (r == -1) {
1433     throw_exception (env, guestfs_last_error (g));
1434     return ;
1435   }
1436 }
1437
1438 JNIEXPORT void JNICALL
1439 Java_com_redhat_et_libguestfs_GuestFS__1touch
1440   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1441 {
1442   guestfs_h *g = (guestfs_h *) (long) jg;
1443   int r;
1444   const char *path;
1445
1446   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1447   r = guestfs_touch (g, path);
1448   (*env)->ReleaseStringUTFChars (env, jpath, path);
1449   if (r == -1) {
1450     throw_exception (env, guestfs_last_error (g));
1451     return ;
1452   }
1453 }
1454
1455 JNIEXPORT jstring JNICALL
1456 Java_com_redhat_et_libguestfs_GuestFS__1cat
1457   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1458 {
1459   guestfs_h *g = (guestfs_h *) (long) jg;
1460   jstring jr;
1461   char *r;
1462   const char *path;
1463
1464   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1465   r = guestfs_cat (g, path);
1466   (*env)->ReleaseStringUTFChars (env, jpath, path);
1467   if (r == NULL) {
1468     throw_exception (env, guestfs_last_error (g));
1469     return NULL;
1470   }
1471   jr = (*env)->NewStringUTF (env, r);
1472   free (r);
1473   return jr;
1474 }
1475
1476 JNIEXPORT jstring JNICALL
1477 Java_com_redhat_et_libguestfs_GuestFS__1ll
1478   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1479 {
1480   guestfs_h *g = (guestfs_h *) (long) jg;
1481   jstring jr;
1482   char *r;
1483   const char *directory;
1484
1485   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1486   r = guestfs_ll (g, directory);
1487   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1488   if (r == NULL) {
1489     throw_exception (env, guestfs_last_error (g));
1490     return NULL;
1491   }
1492   jr = (*env)->NewStringUTF (env, r);
1493   free (r);
1494   return jr;
1495 }
1496
1497 JNIEXPORT jobjectArray JNICALL
1498 Java_com_redhat_et_libguestfs_GuestFS__1ls
1499   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1500 {
1501   guestfs_h *g = (guestfs_h *) (long) jg;
1502   jobjectArray jr;
1503   int r_len;
1504   jclass cl;
1505   jstring jstr;
1506   char **r;
1507   const char *directory;
1508   int i;
1509
1510   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1511   r = guestfs_ls (g, directory);
1512   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1513   if (r == NULL) {
1514     throw_exception (env, guestfs_last_error (g));
1515     return NULL;
1516   }
1517   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1518   cl = (*env)->FindClass (env, "java/lang/String");
1519   jstr = (*env)->NewStringUTF (env, "");
1520   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1521   for (i = 0; i < r_len; ++i) {
1522     jstr = (*env)->NewStringUTF (env, r[i]);
1523     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1524     free (r[i]);
1525   }
1526   free (r);
1527   return jr;
1528 }
1529
1530 JNIEXPORT jobjectArray JNICALL
1531 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
1532   (JNIEnv *env, jobject obj, jlong jg)
1533 {
1534   guestfs_h *g = (guestfs_h *) (long) jg;
1535   jobjectArray jr;
1536   int r_len;
1537   jclass cl;
1538   jstring jstr;
1539   char **r;
1540   int i;
1541
1542   r = guestfs_list_devices (g);
1543   if (r == NULL) {
1544     throw_exception (env, guestfs_last_error (g));
1545     return NULL;
1546   }
1547   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1548   cl = (*env)->FindClass (env, "java/lang/String");
1549   jstr = (*env)->NewStringUTF (env, "");
1550   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1551   for (i = 0; i < r_len; ++i) {
1552     jstr = (*env)->NewStringUTF (env, r[i]);
1553     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1554     free (r[i]);
1555   }
1556   free (r);
1557   return jr;
1558 }
1559
1560 JNIEXPORT jobjectArray JNICALL
1561 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
1562   (JNIEnv *env, jobject obj, jlong jg)
1563 {
1564   guestfs_h *g = (guestfs_h *) (long) jg;
1565   jobjectArray jr;
1566   int r_len;
1567   jclass cl;
1568   jstring jstr;
1569   char **r;
1570   int i;
1571
1572   r = guestfs_list_partitions (g);
1573   if (r == NULL) {
1574     throw_exception (env, guestfs_last_error (g));
1575     return NULL;
1576   }
1577   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1578   cl = (*env)->FindClass (env, "java/lang/String");
1579   jstr = (*env)->NewStringUTF (env, "");
1580   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1581   for (i = 0; i < r_len; ++i) {
1582     jstr = (*env)->NewStringUTF (env, r[i]);
1583     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1584     free (r[i]);
1585   }
1586   free (r);
1587   return jr;
1588 }
1589
1590 JNIEXPORT jobjectArray JNICALL
1591 Java_com_redhat_et_libguestfs_GuestFS__1pvs
1592   (JNIEnv *env, jobject obj, jlong jg)
1593 {
1594   guestfs_h *g = (guestfs_h *) (long) jg;
1595   jobjectArray jr;
1596   int r_len;
1597   jclass cl;
1598   jstring jstr;
1599   char **r;
1600   int i;
1601
1602   r = guestfs_pvs (g);
1603   if (r == NULL) {
1604     throw_exception (env, guestfs_last_error (g));
1605     return NULL;
1606   }
1607   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1608   cl = (*env)->FindClass (env, "java/lang/String");
1609   jstr = (*env)->NewStringUTF (env, "");
1610   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1611   for (i = 0; i < r_len; ++i) {
1612     jstr = (*env)->NewStringUTF (env, r[i]);
1613     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1614     free (r[i]);
1615   }
1616   free (r);
1617   return jr;
1618 }
1619
1620 JNIEXPORT jobjectArray JNICALL
1621 Java_com_redhat_et_libguestfs_GuestFS__1vgs
1622   (JNIEnv *env, jobject obj, jlong jg)
1623 {
1624   guestfs_h *g = (guestfs_h *) (long) jg;
1625   jobjectArray jr;
1626   int r_len;
1627   jclass cl;
1628   jstring jstr;
1629   char **r;
1630   int i;
1631
1632   r = guestfs_vgs (g);
1633   if (r == NULL) {
1634     throw_exception (env, guestfs_last_error (g));
1635     return NULL;
1636   }
1637   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1638   cl = (*env)->FindClass (env, "java/lang/String");
1639   jstr = (*env)->NewStringUTF (env, "");
1640   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1641   for (i = 0; i < r_len; ++i) {
1642     jstr = (*env)->NewStringUTF (env, r[i]);
1643     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1644     free (r[i]);
1645   }
1646   free (r);
1647   return jr;
1648 }
1649
1650 JNIEXPORT jobjectArray JNICALL
1651 Java_com_redhat_et_libguestfs_GuestFS__1lvs
1652   (JNIEnv *env, jobject obj, jlong jg)
1653 {
1654   guestfs_h *g = (guestfs_h *) (long) jg;
1655   jobjectArray jr;
1656   int r_len;
1657   jclass cl;
1658   jstring jstr;
1659   char **r;
1660   int i;
1661
1662   r = guestfs_lvs (g);
1663   if (r == NULL) {
1664     throw_exception (env, guestfs_last_error (g));
1665     return NULL;
1666   }
1667   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1668   cl = (*env)->FindClass (env, "java/lang/String");
1669   jstr = (*env)->NewStringUTF (env, "");
1670   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1671   for (i = 0; i < r_len; ++i) {
1672     jstr = (*env)->NewStringUTF (env, r[i]);
1673     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1674     free (r[i]);
1675   }
1676   free (r);
1677   return jr;
1678 }
1679
1680 JNIEXPORT jobjectArray JNICALL
1681 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
1682   (JNIEnv *env, jobject obj, jlong jg)
1683 {
1684   guestfs_h *g = (guestfs_h *) (long) jg;
1685   jobjectArray jr;
1686   jclass cl;
1687   jfieldID fl;
1688   jobject jfl;
1689   struct guestfs_lvm_pv_list *r;
1690   int i;
1691
1692   r = guestfs_pvs_full (g);
1693   if (r == NULL) {
1694     throw_exception (env, guestfs_last_error (g));
1695     return NULL;
1696   }
1697   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
1698   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1699   for (i = 0; i < r->len; ++i) {
1700     jfl = (*env)->AllocObject (env, cl);
1701     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
1702     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
1703     {
1704       char s[33];
1705       memcpy (s, r->val[i].pv_uuid, 32);
1706       s[32] = 0;
1707       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
1708       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1709     }
1710     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
1711     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
1712     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
1713     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
1714     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
1715     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
1716     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
1717     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
1718     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
1719     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
1720     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
1721     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
1722     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
1723     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
1724     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
1725     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
1726     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
1727     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
1728     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
1729     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
1730     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
1731     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
1732     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
1733     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
1734     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1735   }
1736   guestfs_free_lvm_pv_list (r);
1737   return jr;
1738 }
1739
1740 JNIEXPORT jobjectArray JNICALL
1741 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
1742   (JNIEnv *env, jobject obj, jlong jg)
1743 {
1744   guestfs_h *g = (guestfs_h *) (long) jg;
1745   jobjectArray jr;
1746   jclass cl;
1747   jfieldID fl;
1748   jobject jfl;
1749   struct guestfs_lvm_vg_list *r;
1750   int i;
1751
1752   r = guestfs_vgs_full (g);
1753   if (r == NULL) {
1754     throw_exception (env, guestfs_last_error (g));
1755     return NULL;
1756   }
1757   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
1758   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1759   for (i = 0; i < r->len; ++i) {
1760     jfl = (*env)->AllocObject (env, cl);
1761     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
1762     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
1763     {
1764       char s[33];
1765       memcpy (s, r->val[i].vg_uuid, 32);
1766       s[32] = 0;
1767       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
1768       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1769     }
1770     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
1771     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
1772     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
1773     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
1774     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
1775     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
1776     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
1777     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
1778     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
1779     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
1780     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
1781     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
1782     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
1783     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
1784     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
1785     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
1786     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
1787     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
1788     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
1789     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
1790     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
1791     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
1792     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
1793     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
1794     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
1795     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
1796     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
1797     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
1798     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
1799     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
1800     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
1801     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
1802     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
1803     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
1804     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1805   }
1806   guestfs_free_lvm_vg_list (r);
1807   return jr;
1808 }
1809
1810 JNIEXPORT jobjectArray JNICALL
1811 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
1812   (JNIEnv *env, jobject obj, jlong jg)
1813 {
1814   guestfs_h *g = (guestfs_h *) (long) jg;
1815   jobjectArray jr;
1816   jclass cl;
1817   jfieldID fl;
1818   jobject jfl;
1819   struct guestfs_lvm_lv_list *r;
1820   int i;
1821
1822   r = guestfs_lvs_full (g);
1823   if (r == NULL) {
1824     throw_exception (env, guestfs_last_error (g));
1825     return NULL;
1826   }
1827   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
1828   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1829   for (i = 0; i < r->len; ++i) {
1830     jfl = (*env)->AllocObject (env, cl);
1831     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
1832     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
1833     {
1834       char s[33];
1835       memcpy (s, r->val[i].lv_uuid, 32);
1836       s[32] = 0;
1837       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
1838       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1839     }
1840     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
1841     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
1842     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
1843     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
1844     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
1845     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
1846     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
1847     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
1848     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
1849     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
1850     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
1851     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
1852     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
1853     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
1854     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
1855     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
1856     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
1857     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
1858     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
1859     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
1860     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
1861     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
1862     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
1863     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
1864     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
1865     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
1866     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
1867     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
1868     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1869   }
1870   guestfs_free_lvm_lv_list (r);
1871   return jr;
1872 }
1873
1874 JNIEXPORT jobjectArray JNICALL
1875 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
1876   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1877 {
1878   guestfs_h *g = (guestfs_h *) (long) jg;
1879   jobjectArray jr;
1880   int r_len;
1881   jclass cl;
1882   jstring jstr;
1883   char **r;
1884   const char *path;
1885   int i;
1886
1887   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1888   r = guestfs_read_lines (g, path);
1889   (*env)->ReleaseStringUTFChars (env, jpath, path);
1890   if (r == NULL) {
1891     throw_exception (env, guestfs_last_error (g));
1892     return NULL;
1893   }
1894   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1895   cl = (*env)->FindClass (env, "java/lang/String");
1896   jstr = (*env)->NewStringUTF (env, "");
1897   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1898   for (i = 0; i < r_len; ++i) {
1899     jstr = (*env)->NewStringUTF (env, r[i]);
1900     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1901     free (r[i]);
1902   }
1903   free (r);
1904   return jr;
1905 }
1906
1907 JNIEXPORT void JNICALL
1908 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
1909   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
1910 {
1911   guestfs_h *g = (guestfs_h *) (long) jg;
1912   int r;
1913   const char *root;
1914   int flags;
1915
1916   root = (*env)->GetStringUTFChars (env, jroot, NULL);
1917   flags = jflags;
1918   r = guestfs_aug_init (g, root, flags);
1919   (*env)->ReleaseStringUTFChars (env, jroot, root);
1920   if (r == -1) {
1921     throw_exception (env, guestfs_last_error (g));
1922     return ;
1923   }
1924 }
1925
1926 JNIEXPORT void JNICALL
1927 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
1928   (JNIEnv *env, jobject obj, jlong jg)
1929 {
1930   guestfs_h *g = (guestfs_h *) (long) jg;
1931   int r;
1932
1933   r = guestfs_aug_close (g);
1934   if (r == -1) {
1935     throw_exception (env, guestfs_last_error (g));
1936     return ;
1937   }
1938 }
1939
1940 JNIEXPORT jint JNICALL
1941 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
1942   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
1943 {
1944   guestfs_h *g = (guestfs_h *) (long) jg;
1945   int r;
1946   const char *name;
1947   const char *expr;
1948
1949   name = (*env)->GetStringUTFChars (env, jname, NULL);
1950   expr = jexpr ? (*env)->GetStringUTFChars (env, jexpr, NULL) : NULL;
1951   r = guestfs_aug_defvar (g, name, expr);
1952   (*env)->ReleaseStringUTFChars (env, jname, name);
1953   if (jexpr)
1954     (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1955   if (r == -1) {
1956     throw_exception (env, guestfs_last_error (g));
1957     return 0;
1958   }
1959   return (jint) r;
1960 }
1961
1962 JNIEXPORT jobject JNICALL
1963 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
1964   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
1965 {
1966   guestfs_h *g = (guestfs_h *) (long) jg;
1967   jobject jr;
1968   jclass cl;
1969   jfieldID fl;
1970   struct guestfs_int_bool *r;
1971   const char *name;
1972   const char *expr;
1973   const char *val;
1974
1975   name = (*env)->GetStringUTFChars (env, jname, NULL);
1976   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
1977   val = (*env)->GetStringUTFChars (env, jval, NULL);
1978   r = guestfs_aug_defnode (g, name, expr, val);
1979   (*env)->ReleaseStringUTFChars (env, jname, name);
1980   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1981   (*env)->ReleaseStringUTFChars (env, jval, val);
1982   if (r == NULL) {
1983     throw_exception (env, guestfs_last_error (g));
1984     return NULL;
1985   }
1986   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
1987   jr = (*env)->AllocObject (env, cl);
1988   fl = (*env)->GetFieldID (env, cl, "i", "I");
1989   (*env)->SetIntField (env, jr, fl, r->i);
1990   fl = (*env)->GetFieldID (env, cl, "i", "Z");
1991   (*env)->SetBooleanField (env, jr, fl, r->b);
1992   guestfs_free_int_bool (r);
1993   return jr;
1994 }
1995
1996 JNIEXPORT jstring JNICALL
1997 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
1998   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1999 {
2000   guestfs_h *g = (guestfs_h *) (long) jg;
2001   jstring jr;
2002   char *r;
2003   const char *path;
2004
2005   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2006   r = guestfs_aug_get (g, path);
2007   (*env)->ReleaseStringUTFChars (env, jpath, path);
2008   if (r == NULL) {
2009     throw_exception (env, guestfs_last_error (g));
2010     return NULL;
2011   }
2012   jr = (*env)->NewStringUTF (env, r);
2013   free (r);
2014   return jr;
2015 }
2016
2017 JNIEXPORT void JNICALL
2018 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
2019   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
2020 {
2021   guestfs_h *g = (guestfs_h *) (long) jg;
2022   int r;
2023   const char *path;
2024   const char *val;
2025
2026   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2027   val = (*env)->GetStringUTFChars (env, jval, NULL);
2028   r = guestfs_aug_set (g, path, val);
2029   (*env)->ReleaseStringUTFChars (env, jpath, path);
2030   (*env)->ReleaseStringUTFChars (env, jval, val);
2031   if (r == -1) {
2032     throw_exception (env, guestfs_last_error (g));
2033     return ;
2034   }
2035 }
2036
2037 JNIEXPORT void JNICALL
2038 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
2039   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
2040 {
2041   guestfs_h *g = (guestfs_h *) (long) jg;
2042   int r;
2043   const char *path;
2044   const char *label;
2045   int before;
2046
2047   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2048   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2049   before = jbefore;
2050   r = guestfs_aug_insert (g, path, label, before);
2051   (*env)->ReleaseStringUTFChars (env, jpath, path);
2052   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2053   if (r == -1) {
2054     throw_exception (env, guestfs_last_error (g));
2055     return ;
2056   }
2057 }
2058
2059 JNIEXPORT jint JNICALL
2060 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
2061   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2062 {
2063   guestfs_h *g = (guestfs_h *) (long) jg;
2064   int r;
2065   const char *path;
2066
2067   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2068   r = guestfs_aug_rm (g, path);
2069   (*env)->ReleaseStringUTFChars (env, jpath, path);
2070   if (r == -1) {
2071     throw_exception (env, guestfs_last_error (g));
2072     return 0;
2073   }
2074   return (jint) r;
2075 }
2076
2077 JNIEXPORT void JNICALL
2078 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
2079   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2080 {
2081   guestfs_h *g = (guestfs_h *) (long) jg;
2082   int r;
2083   const char *src;
2084   const char *dest;
2085
2086   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2087   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2088   r = guestfs_aug_mv (g, src, dest);
2089   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2090   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2091   if (r == -1) {
2092     throw_exception (env, guestfs_last_error (g));
2093     return ;
2094   }
2095 }
2096
2097 JNIEXPORT jobjectArray JNICALL
2098 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
2099   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2100 {
2101   guestfs_h *g = (guestfs_h *) (long) jg;
2102   jobjectArray jr;
2103   int r_len;
2104   jclass cl;
2105   jstring jstr;
2106   char **r;
2107   const char *path;
2108   int i;
2109
2110   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2111   r = guestfs_aug_match (g, path);
2112   (*env)->ReleaseStringUTFChars (env, jpath, path);
2113   if (r == NULL) {
2114     throw_exception (env, guestfs_last_error (g));
2115     return NULL;
2116   }
2117   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2118   cl = (*env)->FindClass (env, "java/lang/String");
2119   jstr = (*env)->NewStringUTF (env, "");
2120   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2121   for (i = 0; i < r_len; ++i) {
2122     jstr = (*env)->NewStringUTF (env, r[i]);
2123     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2124     free (r[i]);
2125   }
2126   free (r);
2127   return jr;
2128 }
2129
2130 JNIEXPORT void JNICALL
2131 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
2132   (JNIEnv *env, jobject obj, jlong jg)
2133 {
2134   guestfs_h *g = (guestfs_h *) (long) jg;
2135   int r;
2136
2137   r = guestfs_aug_save (g);
2138   if (r == -1) {
2139     throw_exception (env, guestfs_last_error (g));
2140     return ;
2141   }
2142 }
2143
2144 JNIEXPORT void JNICALL
2145 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
2146   (JNIEnv *env, jobject obj, jlong jg)
2147 {
2148   guestfs_h *g = (guestfs_h *) (long) jg;
2149   int r;
2150
2151   r = guestfs_aug_load (g);
2152   if (r == -1) {
2153     throw_exception (env, guestfs_last_error (g));
2154     return ;
2155   }
2156 }
2157
2158 JNIEXPORT jobjectArray JNICALL
2159 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
2160   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2161 {
2162   guestfs_h *g = (guestfs_h *) (long) jg;
2163   jobjectArray jr;
2164   int r_len;
2165   jclass cl;
2166   jstring jstr;
2167   char **r;
2168   const char *path;
2169   int i;
2170
2171   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2172   r = guestfs_aug_ls (g, path);
2173   (*env)->ReleaseStringUTFChars (env, jpath, path);
2174   if (r == NULL) {
2175     throw_exception (env, guestfs_last_error (g));
2176     return NULL;
2177   }
2178   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2179   cl = (*env)->FindClass (env, "java/lang/String");
2180   jstr = (*env)->NewStringUTF (env, "");
2181   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2182   for (i = 0; i < r_len; ++i) {
2183     jstr = (*env)->NewStringUTF (env, r[i]);
2184     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2185     free (r[i]);
2186   }
2187   free (r);
2188   return jr;
2189 }
2190
2191 JNIEXPORT void JNICALL
2192 Java_com_redhat_et_libguestfs_GuestFS__1rm
2193   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2194 {
2195   guestfs_h *g = (guestfs_h *) (long) jg;
2196   int r;
2197   const char *path;
2198
2199   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2200   r = guestfs_rm (g, path);
2201   (*env)->ReleaseStringUTFChars (env, jpath, path);
2202   if (r == -1) {
2203     throw_exception (env, guestfs_last_error (g));
2204     return ;
2205   }
2206 }
2207
2208 JNIEXPORT void JNICALL
2209 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
2210   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2211 {
2212   guestfs_h *g = (guestfs_h *) (long) jg;
2213   int r;
2214   const char *path;
2215
2216   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2217   r = guestfs_rmdir (g, path);
2218   (*env)->ReleaseStringUTFChars (env, jpath, path);
2219   if (r == -1) {
2220     throw_exception (env, guestfs_last_error (g));
2221     return ;
2222   }
2223 }
2224
2225 JNIEXPORT void JNICALL
2226 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
2227   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2228 {
2229   guestfs_h *g = (guestfs_h *) (long) jg;
2230   int r;
2231   const char *path;
2232
2233   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2234   r = guestfs_rm_rf (g, path);
2235   (*env)->ReleaseStringUTFChars (env, jpath, path);
2236   if (r == -1) {
2237     throw_exception (env, guestfs_last_error (g));
2238     return ;
2239   }
2240 }
2241
2242 JNIEXPORT void JNICALL
2243 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
2244   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2245 {
2246   guestfs_h *g = (guestfs_h *) (long) jg;
2247   int r;
2248   const char *path;
2249
2250   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2251   r = guestfs_mkdir (g, path);
2252   (*env)->ReleaseStringUTFChars (env, jpath, path);
2253   if (r == -1) {
2254     throw_exception (env, guestfs_last_error (g));
2255     return ;
2256   }
2257 }
2258
2259 JNIEXPORT void JNICALL
2260 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
2261   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2262 {
2263   guestfs_h *g = (guestfs_h *) (long) jg;
2264   int r;
2265   const char *path;
2266
2267   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2268   r = guestfs_mkdir_p (g, path);
2269   (*env)->ReleaseStringUTFChars (env, jpath, path);
2270   if (r == -1) {
2271     throw_exception (env, guestfs_last_error (g));
2272     return ;
2273   }
2274 }
2275
2276 JNIEXPORT void JNICALL
2277 Java_com_redhat_et_libguestfs_GuestFS__1chmod
2278   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
2279 {
2280   guestfs_h *g = (guestfs_h *) (long) jg;
2281   int r;
2282   int mode;
2283   const char *path;
2284
2285   mode = jmode;
2286   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2287   r = guestfs_chmod (g, mode, path);
2288   (*env)->ReleaseStringUTFChars (env, jpath, path);
2289   if (r == -1) {
2290     throw_exception (env, guestfs_last_error (g));
2291     return ;
2292   }
2293 }
2294
2295 JNIEXPORT void JNICALL
2296 Java_com_redhat_et_libguestfs_GuestFS__1chown
2297   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
2298 {
2299   guestfs_h *g = (guestfs_h *) (long) jg;
2300   int r;
2301   int owner;
2302   int group;
2303   const char *path;
2304
2305   owner = jowner;
2306   group = jgroup;
2307   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2308   r = guestfs_chown (g, owner, group, path);
2309   (*env)->ReleaseStringUTFChars (env, jpath, path);
2310   if (r == -1) {
2311     throw_exception (env, guestfs_last_error (g));
2312     return ;
2313   }
2314 }
2315
2316 JNIEXPORT jboolean JNICALL
2317 Java_com_redhat_et_libguestfs_GuestFS__1exists
2318   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2319 {
2320   guestfs_h *g = (guestfs_h *) (long) jg;
2321   int r;
2322   const char *path;
2323
2324   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2325   r = guestfs_exists (g, path);
2326   (*env)->ReleaseStringUTFChars (env, jpath, path);
2327   if (r == -1) {
2328     throw_exception (env, guestfs_last_error (g));
2329     return 0;
2330   }
2331   return (jboolean) r;
2332 }
2333
2334 JNIEXPORT jboolean JNICALL
2335 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
2336   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2337 {
2338   guestfs_h *g = (guestfs_h *) (long) jg;
2339   int r;
2340   const char *path;
2341
2342   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2343   r = guestfs_is_file (g, path);
2344   (*env)->ReleaseStringUTFChars (env, jpath, path);
2345   if (r == -1) {
2346     throw_exception (env, guestfs_last_error (g));
2347     return 0;
2348   }
2349   return (jboolean) r;
2350 }
2351
2352 JNIEXPORT jboolean JNICALL
2353 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
2354   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2355 {
2356   guestfs_h *g = (guestfs_h *) (long) jg;
2357   int r;
2358   const char *path;
2359
2360   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2361   r = guestfs_is_dir (g, path);
2362   (*env)->ReleaseStringUTFChars (env, jpath, path);
2363   if (r == -1) {
2364     throw_exception (env, guestfs_last_error (g));
2365     return 0;
2366   }
2367   return (jboolean) r;
2368 }
2369
2370 JNIEXPORT void JNICALL
2371 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
2372   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2373 {
2374   guestfs_h *g = (guestfs_h *) (long) jg;
2375   int r;
2376   const char *device;
2377
2378   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2379   r = guestfs_pvcreate (g, device);
2380   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2381   if (r == -1) {
2382     throw_exception (env, guestfs_last_error (g));
2383     return ;
2384   }
2385 }
2386
2387 JNIEXPORT void JNICALL
2388 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
2389   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
2390 {
2391   guestfs_h *g = (guestfs_h *) (long) jg;
2392   int r;
2393   const char *volgroup;
2394   int physvols_len;
2395   const char **physvols;
2396   int i;
2397
2398   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2399   physvols_len = (*env)->GetArrayLength (env, jphysvols);
2400   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
2401   for (i = 0; i < physvols_len; ++i) {
2402     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2403     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
2404   }
2405   physvols[physvols_len] = NULL;
2406   r = guestfs_vgcreate (g, volgroup, physvols);
2407   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2408   for (i = 0; i < physvols_len; ++i) {
2409     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2410     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
2411   }
2412   free (physvols);
2413   if (r == -1) {
2414     throw_exception (env, guestfs_last_error (g));
2415     return ;
2416   }
2417 }
2418
2419 JNIEXPORT void JNICALL
2420 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
2421   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
2422 {
2423   guestfs_h *g = (guestfs_h *) (long) jg;
2424   int r;
2425   const char *logvol;
2426   const char *volgroup;
2427   int mbytes;
2428
2429   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
2430   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2431   mbytes = jmbytes;
2432   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2433   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
2434   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2435   if (r == -1) {
2436     throw_exception (env, guestfs_last_error (g));
2437     return ;
2438   }
2439 }
2440
2441 JNIEXPORT void JNICALL
2442 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
2443   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2444 {
2445   guestfs_h *g = (guestfs_h *) (long) jg;
2446   int r;
2447   const char *fstype;
2448   const char *device;
2449
2450   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2451   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2452   r = guestfs_mkfs (g, fstype, device);
2453   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2454   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2455   if (r == -1) {
2456     throw_exception (env, guestfs_last_error (g));
2457     return ;
2458   }
2459 }
2460
2461 JNIEXPORT void JNICALL
2462 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
2463   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
2464 {
2465   guestfs_h *g = (guestfs_h *) (long) jg;
2466   int r;
2467   const char *device;
2468   int cyls;
2469   int heads;
2470   int sectors;
2471   int lines_len;
2472   const char **lines;
2473   int i;
2474
2475   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2476   cyls = jcyls;
2477   heads = jheads;
2478   sectors = jsectors;
2479   lines_len = (*env)->GetArrayLength (env, jlines);
2480   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
2481   for (i = 0; i < lines_len; ++i) {
2482     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2483     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
2484   }
2485   lines[lines_len] = NULL;
2486   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2487   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2488   for (i = 0; i < lines_len; ++i) {
2489     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2490     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
2491   }
2492   free (lines);
2493   if (r == -1) {
2494     throw_exception (env, guestfs_last_error (g));
2495     return ;
2496   }
2497 }
2498
2499 JNIEXPORT void JNICALL
2500 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
2501   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
2502 {
2503   guestfs_h *g = (guestfs_h *) (long) jg;
2504   int r;
2505   const char *path;
2506   const char *content;
2507   int size;
2508
2509   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2510   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
2511   size = jsize;
2512   r = guestfs_write_file (g, path, content, size);
2513   (*env)->ReleaseStringUTFChars (env, jpath, path);
2514   (*env)->ReleaseStringUTFChars (env, jcontent, content);
2515   if (r == -1) {
2516     throw_exception (env, guestfs_last_error (g));
2517     return ;
2518   }
2519 }
2520
2521 JNIEXPORT void JNICALL
2522 Java_com_redhat_et_libguestfs_GuestFS__1umount
2523   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
2524 {
2525   guestfs_h *g = (guestfs_h *) (long) jg;
2526   int r;
2527   const char *pathordevice;
2528
2529   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
2530   r = guestfs_umount (g, pathordevice);
2531   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
2532   if (r == -1) {
2533     throw_exception (env, guestfs_last_error (g));
2534     return ;
2535   }
2536 }
2537
2538 JNIEXPORT jobjectArray JNICALL
2539 Java_com_redhat_et_libguestfs_GuestFS__1mounts
2540   (JNIEnv *env, jobject obj, jlong jg)
2541 {
2542   guestfs_h *g = (guestfs_h *) (long) jg;
2543   jobjectArray jr;
2544   int r_len;
2545   jclass cl;
2546   jstring jstr;
2547   char **r;
2548   int i;
2549
2550   r = guestfs_mounts (g);
2551   if (r == NULL) {
2552     throw_exception (env, guestfs_last_error (g));
2553     return NULL;
2554   }
2555   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2556   cl = (*env)->FindClass (env, "java/lang/String");
2557   jstr = (*env)->NewStringUTF (env, "");
2558   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2559   for (i = 0; i < r_len; ++i) {
2560     jstr = (*env)->NewStringUTF (env, r[i]);
2561     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2562     free (r[i]);
2563   }
2564   free (r);
2565   return jr;
2566 }
2567
2568 JNIEXPORT void JNICALL
2569 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
2570   (JNIEnv *env, jobject obj, jlong jg)
2571 {
2572   guestfs_h *g = (guestfs_h *) (long) jg;
2573   int r;
2574
2575   r = guestfs_umount_all (g);
2576   if (r == -1) {
2577     throw_exception (env, guestfs_last_error (g));
2578     return ;
2579   }
2580 }
2581
2582 JNIEXPORT void JNICALL
2583 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
2584   (JNIEnv *env, jobject obj, jlong jg)
2585 {
2586   guestfs_h *g = (guestfs_h *) (long) jg;
2587   int r;
2588
2589   r = guestfs_lvm_remove_all (g);
2590   if (r == -1) {
2591     throw_exception (env, guestfs_last_error (g));
2592     return ;
2593   }
2594 }
2595
2596 JNIEXPORT jstring JNICALL
2597 Java_com_redhat_et_libguestfs_GuestFS__1file
2598   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2599 {
2600   guestfs_h *g = (guestfs_h *) (long) jg;
2601   jstring jr;
2602   char *r;
2603   const char *path;
2604
2605   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2606   r = guestfs_file (g, path);
2607   (*env)->ReleaseStringUTFChars (env, jpath, path);
2608   if (r == NULL) {
2609     throw_exception (env, guestfs_last_error (g));
2610     return NULL;
2611   }
2612   jr = (*env)->NewStringUTF (env, r);
2613   free (r);
2614   return jr;
2615 }
2616
2617 JNIEXPORT jstring JNICALL
2618 Java_com_redhat_et_libguestfs_GuestFS__1command
2619   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2620 {
2621   guestfs_h *g = (guestfs_h *) (long) jg;
2622   jstring jr;
2623   char *r;
2624   int arguments_len;
2625   const char **arguments;
2626   int i;
2627
2628   arguments_len = (*env)->GetArrayLength (env, jarguments);
2629   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2630   for (i = 0; i < arguments_len; ++i) {
2631     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2632     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2633   }
2634   arguments[arguments_len] = NULL;
2635   r = guestfs_command (g, arguments);
2636   for (i = 0; i < arguments_len; ++i) {
2637     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2638     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2639   }
2640   free (arguments);
2641   if (r == NULL) {
2642     throw_exception (env, guestfs_last_error (g));
2643     return NULL;
2644   }
2645   jr = (*env)->NewStringUTF (env, r);
2646   free (r);
2647   return jr;
2648 }
2649
2650 JNIEXPORT jobjectArray JNICALL
2651 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
2652   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2653 {
2654   guestfs_h *g = (guestfs_h *) (long) jg;
2655   jobjectArray jr;
2656   int r_len;
2657   jclass cl;
2658   jstring jstr;
2659   char **r;
2660   int arguments_len;
2661   const char **arguments;
2662   int i;
2663
2664   arguments_len = (*env)->GetArrayLength (env, jarguments);
2665   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2666   for (i = 0; i < arguments_len; ++i) {
2667     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2668     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2669   }
2670   arguments[arguments_len] = NULL;
2671   r = guestfs_command_lines (g, arguments);
2672   for (i = 0; i < arguments_len; ++i) {
2673     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2674     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2675   }
2676   free (arguments);
2677   if (r == NULL) {
2678     throw_exception (env, guestfs_last_error (g));
2679     return NULL;
2680   }
2681   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2682   cl = (*env)->FindClass (env, "java/lang/String");
2683   jstr = (*env)->NewStringUTF (env, "");
2684   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2685   for (i = 0; i < r_len; ++i) {
2686     jstr = (*env)->NewStringUTF (env, r[i]);
2687     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2688     free (r[i]);
2689   }
2690   free (r);
2691   return jr;
2692 }
2693
2694 JNIEXPORT jobject JNICALL
2695 Java_com_redhat_et_libguestfs_GuestFS__1stat
2696   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2697 {
2698   guestfs_h *g = (guestfs_h *) (long) jg;
2699   jobject jr;
2700   jclass cl;
2701   jfieldID fl;
2702   struct guestfs_stat *r;
2703   const char *path;
2704
2705   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2706   r = guestfs_stat (g, path);
2707   (*env)->ReleaseStringUTFChars (env, jpath, path);
2708   if (r == NULL) {
2709     throw_exception (env, guestfs_last_error (g));
2710     return NULL;
2711   }
2712   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2713   jr = (*env)->AllocObject (env, cl);
2714   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2715   (*env)->SetLongField (env, jr, fl, r->dev);
2716   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2717   (*env)->SetLongField (env, jr, fl, r->ino);
2718   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2719   (*env)->SetLongField (env, jr, fl, r->mode);
2720   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2721   (*env)->SetLongField (env, jr, fl, r->nlink);
2722   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2723   (*env)->SetLongField (env, jr, fl, r->uid);
2724   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2725   (*env)->SetLongField (env, jr, fl, r->gid);
2726   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2727   (*env)->SetLongField (env, jr, fl, r->rdev);
2728   fl = (*env)->GetFieldID (env, cl, "size", "J");
2729   (*env)->SetLongField (env, jr, fl, r->size);
2730   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2731   (*env)->SetLongField (env, jr, fl, r->blksize);
2732   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2733   (*env)->SetLongField (env, jr, fl, r->blocks);
2734   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2735   (*env)->SetLongField (env, jr, fl, r->atime);
2736   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2737   (*env)->SetLongField (env, jr, fl, r->mtime);
2738   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2739   (*env)->SetLongField (env, jr, fl, r->ctime);
2740   free (r);
2741   return jr;
2742 }
2743
2744 JNIEXPORT jobject JNICALL
2745 Java_com_redhat_et_libguestfs_GuestFS__1lstat
2746   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2747 {
2748   guestfs_h *g = (guestfs_h *) (long) jg;
2749   jobject jr;
2750   jclass cl;
2751   jfieldID fl;
2752   struct guestfs_stat *r;
2753   const char *path;
2754
2755   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2756   r = guestfs_lstat (g, path);
2757   (*env)->ReleaseStringUTFChars (env, jpath, path);
2758   if (r == NULL) {
2759     throw_exception (env, guestfs_last_error (g));
2760     return NULL;
2761   }
2762   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2763   jr = (*env)->AllocObject (env, cl);
2764   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2765   (*env)->SetLongField (env, jr, fl, r->dev);
2766   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2767   (*env)->SetLongField (env, jr, fl, r->ino);
2768   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2769   (*env)->SetLongField (env, jr, fl, r->mode);
2770   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2771   (*env)->SetLongField (env, jr, fl, r->nlink);
2772   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2773   (*env)->SetLongField (env, jr, fl, r->uid);
2774   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2775   (*env)->SetLongField (env, jr, fl, r->gid);
2776   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2777   (*env)->SetLongField (env, jr, fl, r->rdev);
2778   fl = (*env)->GetFieldID (env, cl, "size", "J");
2779   (*env)->SetLongField (env, jr, fl, r->size);
2780   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2781   (*env)->SetLongField (env, jr, fl, r->blksize);
2782   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2783   (*env)->SetLongField (env, jr, fl, r->blocks);
2784   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2785   (*env)->SetLongField (env, jr, fl, r->atime);
2786   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2787   (*env)->SetLongField (env, jr, fl, r->mtime);
2788   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2789   (*env)->SetLongField (env, jr, fl, r->ctime);
2790   free (r);
2791   return jr;
2792 }
2793
2794 JNIEXPORT jobject JNICALL
2795 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
2796   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2797 {
2798   guestfs_h *g = (guestfs_h *) (long) jg;
2799   jobject jr;
2800   jclass cl;
2801   jfieldID fl;
2802   struct guestfs_statvfs *r;
2803   const char *path;
2804
2805   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2806   r = guestfs_statvfs (g, path);
2807   (*env)->ReleaseStringUTFChars (env, jpath, path);
2808   if (r == NULL) {
2809     throw_exception (env, guestfs_last_error (g));
2810     return NULL;
2811   }
2812   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
2813   jr = (*env)->AllocObject (env, cl);
2814   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
2815   (*env)->SetLongField (env, jr, fl, r->bsize);
2816   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
2817   (*env)->SetLongField (env, jr, fl, r->frsize);
2818   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2819   (*env)->SetLongField (env, jr, fl, r->blocks);
2820   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
2821   (*env)->SetLongField (env, jr, fl, r->bfree);
2822   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
2823   (*env)->SetLongField (env, jr, fl, r->bavail);
2824   fl = (*env)->GetFieldID (env, cl, "files", "J");
2825   (*env)->SetLongField (env, jr, fl, r->files);
2826   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
2827   (*env)->SetLongField (env, jr, fl, r->ffree);
2828   fl = (*env)->GetFieldID (env, cl, "favail", "J");
2829   (*env)->SetLongField (env, jr, fl, r->favail);
2830   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
2831   (*env)->SetLongField (env, jr, fl, r->fsid);
2832   fl = (*env)->GetFieldID (env, cl, "flag", "J");
2833   (*env)->SetLongField (env, jr, fl, r->flag);
2834   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
2835   (*env)->SetLongField (env, jr, fl, r->namemax);
2836   free (r);
2837   return jr;
2838 }
2839
2840 JNIEXPORT jobject JNICALL
2841 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
2842   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2843 {
2844   guestfs_h *g = (guestfs_h *) (long) jg;
2845   char **r;
2846   const char *device;
2847
2848   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2849   r = guestfs_tune2fs_l (g, device);
2850   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2851   if (r == NULL) {
2852     throw_exception (env, guestfs_last_error (g));
2853     return NULL;
2854   }
2855   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
2856   return NULL;
2857 }
2858
2859 JNIEXPORT void JNICALL
2860 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
2861   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2862 {
2863   guestfs_h *g = (guestfs_h *) (long) jg;
2864   int r;
2865   const char *device;
2866
2867   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2868   r = guestfs_blockdev_setro (g, device);
2869   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2870   if (r == -1) {
2871     throw_exception (env, guestfs_last_error (g));
2872     return ;
2873   }
2874 }
2875
2876 JNIEXPORT void JNICALL
2877 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
2878   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2879 {
2880   guestfs_h *g = (guestfs_h *) (long) jg;
2881   int r;
2882   const char *device;
2883
2884   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2885   r = guestfs_blockdev_setrw (g, device);
2886   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2887   if (r == -1) {
2888     throw_exception (env, guestfs_last_error (g));
2889     return ;
2890   }
2891 }
2892
2893 JNIEXPORT jboolean JNICALL
2894 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
2895   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2896 {
2897   guestfs_h *g = (guestfs_h *) (long) jg;
2898   int r;
2899   const char *device;
2900
2901   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2902   r = guestfs_blockdev_getro (g, device);
2903   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2904   if (r == -1) {
2905     throw_exception (env, guestfs_last_error (g));
2906     return 0;
2907   }
2908   return (jboolean) r;
2909 }
2910
2911 JNIEXPORT jint JNICALL
2912 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
2913   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2914 {
2915   guestfs_h *g = (guestfs_h *) (long) jg;
2916   int r;
2917   const char *device;
2918
2919   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2920   r = guestfs_blockdev_getss (g, device);
2921   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2922   if (r == -1) {
2923     throw_exception (env, guestfs_last_error (g));
2924     return 0;
2925   }
2926   return (jint) r;
2927 }
2928
2929 JNIEXPORT jint JNICALL
2930 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
2931   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2932 {
2933   guestfs_h *g = (guestfs_h *) (long) jg;
2934   int r;
2935   const char *device;
2936
2937   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2938   r = guestfs_blockdev_getbsz (g, device);
2939   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2940   if (r == -1) {
2941     throw_exception (env, guestfs_last_error (g));
2942     return 0;
2943   }
2944   return (jint) r;
2945 }
2946
2947 JNIEXPORT void JNICALL
2948 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
2949   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
2950 {
2951   guestfs_h *g = (guestfs_h *) (long) jg;
2952   int r;
2953   const char *device;
2954   int blocksize;
2955
2956   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2957   blocksize = jblocksize;
2958   r = guestfs_blockdev_setbsz (g, device, blocksize);
2959   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2960   if (r == -1) {
2961     throw_exception (env, guestfs_last_error (g));
2962     return ;
2963   }
2964 }
2965
2966 JNIEXPORT jlong JNICALL
2967 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
2968   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2969 {
2970   guestfs_h *g = (guestfs_h *) (long) jg;
2971   int64_t r;
2972   const char *device;
2973
2974   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2975   r = guestfs_blockdev_getsz (g, device);
2976   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2977   if (r == -1) {
2978     throw_exception (env, guestfs_last_error (g));
2979     return 0;
2980   }
2981   return (jlong) r;
2982 }
2983
2984 JNIEXPORT jlong JNICALL
2985 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
2986   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2987 {
2988   guestfs_h *g = (guestfs_h *) (long) jg;
2989   int64_t r;
2990   const char *device;
2991
2992   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2993   r = guestfs_blockdev_getsize64 (g, device);
2994   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2995   if (r == -1) {
2996     throw_exception (env, guestfs_last_error (g));
2997     return 0;
2998   }
2999   return (jlong) r;
3000 }
3001
3002 JNIEXPORT void JNICALL
3003 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
3004   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3005 {
3006   guestfs_h *g = (guestfs_h *) (long) jg;
3007   int r;
3008   const char *device;
3009
3010   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3011   r = guestfs_blockdev_flushbufs (g, device);
3012   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3013   if (r == -1) {
3014     throw_exception (env, guestfs_last_error (g));
3015     return ;
3016   }
3017 }
3018
3019 JNIEXPORT void JNICALL
3020 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
3021   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3022 {
3023   guestfs_h *g = (guestfs_h *) (long) jg;
3024   int r;
3025   const char *device;
3026
3027   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3028   r = guestfs_blockdev_rereadpt (g, device);
3029   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3030   if (r == -1) {
3031     throw_exception (env, guestfs_last_error (g));
3032     return ;
3033   }
3034 }
3035
3036 JNIEXPORT void JNICALL
3037 Java_com_redhat_et_libguestfs_GuestFS__1upload
3038   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
3039 {
3040   guestfs_h *g = (guestfs_h *) (long) jg;
3041   int r;
3042   const char *filename;
3043   const char *remotefilename;
3044
3045   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3046   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3047   r = guestfs_upload (g, filename, remotefilename);
3048   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3049   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3050   if (r == -1) {
3051     throw_exception (env, guestfs_last_error (g));
3052     return ;
3053   }
3054 }
3055
3056 JNIEXPORT void JNICALL
3057 Java_com_redhat_et_libguestfs_GuestFS__1download
3058   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
3059 {
3060   guestfs_h *g = (guestfs_h *) (long) jg;
3061   int r;
3062   const char *remotefilename;
3063   const char *filename;
3064
3065   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3066   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3067   r = guestfs_download (g, remotefilename, filename);
3068   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3069   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3070   if (r == -1) {
3071     throw_exception (env, guestfs_last_error (g));
3072     return ;
3073   }
3074 }
3075
3076 JNIEXPORT jstring JNICALL
3077 Java_com_redhat_et_libguestfs_GuestFS__1checksum
3078   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
3079 {
3080   guestfs_h *g = (guestfs_h *) (long) jg;
3081   jstring jr;
3082   char *r;
3083   const char *csumtype;
3084   const char *path;
3085
3086   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
3087   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3088   r = guestfs_checksum (g, csumtype, path);
3089   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
3090   (*env)->ReleaseStringUTFChars (env, jpath, path);
3091   if (r == NULL) {
3092     throw_exception (env, guestfs_last_error (g));
3093     return NULL;
3094   }
3095   jr = (*env)->NewStringUTF (env, r);
3096   free (r);
3097   return jr;
3098 }
3099
3100 JNIEXPORT void JNICALL
3101 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
3102   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
3103 {
3104   guestfs_h *g = (guestfs_h *) (long) jg;
3105   int r;
3106   const char *tarfile;
3107   const char *directory;
3108
3109   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3110   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3111   r = guestfs_tar_in (g, tarfile, directory);
3112   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3113   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3114   if (r == -1) {
3115     throw_exception (env, guestfs_last_error (g));
3116     return ;
3117   }
3118 }
3119
3120 JNIEXPORT void JNICALL
3121 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
3122   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
3123 {
3124   guestfs_h *g = (guestfs_h *) (long) jg;
3125   int r;
3126   const char *directory;
3127   const char *tarfile;
3128
3129   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3130   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3131   r = guestfs_tar_out (g, directory, tarfile);
3132   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3133   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3134   if (r == -1) {
3135     throw_exception (env, guestfs_last_error (g));
3136     return ;
3137   }
3138 }
3139
3140 JNIEXPORT void JNICALL
3141 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
3142   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
3143 {
3144   guestfs_h *g = (guestfs_h *) (long) jg;
3145   int r;
3146   const char *tarball;
3147   const char *directory;
3148
3149   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3150   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3151   r = guestfs_tgz_in (g, tarball, directory);
3152   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3153   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3154   if (r == -1) {
3155     throw_exception (env, guestfs_last_error (g));
3156     return ;
3157   }
3158 }
3159
3160 JNIEXPORT void JNICALL
3161 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
3162   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
3163 {
3164   guestfs_h *g = (guestfs_h *) (long) jg;
3165   int r;
3166   const char *directory;
3167   const char *tarball;
3168
3169   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3170   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3171   r = guestfs_tgz_out (g, directory, tarball);
3172   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3173   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3174   if (r == -1) {
3175     throw_exception (env, guestfs_last_error (g));
3176     return ;
3177   }
3178 }
3179
3180 JNIEXPORT void JNICALL
3181 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
3182   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
3183 {
3184   guestfs_h *g = (guestfs_h *) (long) jg;
3185   int r;
3186   const char *device;
3187   const char *mountpoint;
3188
3189   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3190   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3191   r = guestfs_mount_ro (g, device, mountpoint);
3192   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3193   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3194   if (r == -1) {
3195     throw_exception (env, guestfs_last_error (g));
3196     return ;
3197   }
3198 }
3199
3200 JNIEXPORT void JNICALL
3201 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
3202   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
3203 {
3204   guestfs_h *g = (guestfs_h *) (long) jg;
3205   int r;
3206   const char *options;
3207   const char *device;
3208   const char *mountpoint;
3209
3210   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3211   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3212   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3213   r = guestfs_mount_options (g, options, device, mountpoint);
3214   (*env)->ReleaseStringUTFChars (env, joptions, options);
3215   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3216   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3217   if (r == -1) {
3218     throw_exception (env, guestfs_last_error (g));
3219     return ;
3220   }
3221 }
3222
3223 JNIEXPORT void JNICALL
3224 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
3225   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
3226 {
3227   guestfs_h *g = (guestfs_h *) (long) jg;
3228   int r;
3229   const char *options;
3230   const char *vfstype;
3231   const char *device;
3232   const char *mountpoint;
3233
3234   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3235   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
3236   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3237   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3238   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3239   (*env)->ReleaseStringUTFChars (env, joptions, options);
3240   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
3241   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3242   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3243   if (r == -1) {
3244     throw_exception (env, guestfs_last_error (g));
3245     return ;
3246   }
3247 }
3248
3249 JNIEXPORT jstring JNICALL
3250 Java_com_redhat_et_libguestfs_GuestFS__1debug
3251   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
3252 {
3253   guestfs_h *g = (guestfs_h *) (long) jg;
3254   jstring jr;
3255   char *r;
3256   const char *subcmd;
3257   int extraargs_len;
3258   const char **extraargs;
3259   int i;
3260
3261   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
3262   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
3263   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
3264   for (i = 0; i < extraargs_len; ++i) {
3265     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3266     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
3267   }
3268   extraargs[extraargs_len] = NULL;
3269   r = guestfs_debug (g, subcmd, extraargs);
3270   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
3271   for (i = 0; i < extraargs_len; ++i) {
3272     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3273     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
3274   }
3275   free (extraargs);
3276   if (r == NULL) {
3277     throw_exception (env, guestfs_last_error (g));
3278     return NULL;
3279   }
3280   jr = (*env)->NewStringUTF (env, r);
3281   free (r);
3282   return jr;
3283 }
3284
3285 JNIEXPORT void JNICALL
3286 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
3287   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3288 {
3289   guestfs_h *g = (guestfs_h *) (long) jg;
3290   int r;
3291   const char *device;
3292
3293   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3294   r = guestfs_lvremove (g, device);
3295   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3296   if (r == -1) {
3297     throw_exception (env, guestfs_last_error (g));
3298     return ;
3299   }
3300 }
3301
3302 JNIEXPORT void JNICALL
3303 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
3304   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
3305 {
3306   guestfs_h *g = (guestfs_h *) (long) jg;
3307   int r;
3308   const char *vgname;
3309
3310   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
3311   r = guestfs_vgremove (g, vgname);
3312   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
3313   if (r == -1) {
3314     throw_exception (env, guestfs_last_error (g));
3315     return ;
3316   }
3317 }
3318
3319 JNIEXPORT void JNICALL
3320 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
3321   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3322 {
3323   guestfs_h *g = (guestfs_h *) (long) jg;
3324   int r;
3325   const char *device;
3326
3327   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3328   r = guestfs_pvremove (g, device);
3329   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3330   if (r == -1) {
3331     throw_exception (env, guestfs_last_error (g));
3332     return ;
3333   }
3334 }
3335
3336 JNIEXPORT void JNICALL
3337 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
3338   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
3339 {
3340   guestfs_h *g = (guestfs_h *) (long) jg;
3341   int r;
3342   const char *device;
3343   const char *label;
3344
3345   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3346   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
3347   r = guestfs_set_e2label (g, device, label);
3348   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3349   (*env)->ReleaseStringUTFChars (env, jlabel, label);
3350   if (r == -1) {
3351     throw_exception (env, guestfs_last_error (g));
3352     return ;
3353   }
3354 }
3355
3356 JNIEXPORT jstring JNICALL
3357 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
3358   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3359 {
3360   guestfs_h *g = (guestfs_h *) (long) jg;
3361   jstring jr;
3362   char *r;
3363   const char *device;
3364
3365   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3366   r = guestfs_get_e2label (g, device);
3367   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3368   if (r == NULL) {
3369     throw_exception (env, guestfs_last_error (g));
3370     return NULL;
3371   }
3372   jr = (*env)->NewStringUTF (env, r);
3373   free (r);
3374   return jr;
3375 }
3376
3377 JNIEXPORT void JNICALL
3378 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
3379   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
3380 {
3381   guestfs_h *g = (guestfs_h *) (long) jg;
3382   int r;
3383   const char *device;
3384   const char *uuid;
3385
3386   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3387   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
3388   r = guestfs_set_e2uuid (g, device, uuid);
3389   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3390   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
3391   if (r == -1) {
3392     throw_exception (env, guestfs_last_error (g));
3393     return ;
3394   }
3395 }
3396
3397 JNIEXPORT jstring JNICALL
3398 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
3399   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3400 {
3401   guestfs_h *g = (guestfs_h *) (long) jg;
3402   jstring jr;
3403   char *r;
3404   const char *device;
3405
3406   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3407   r = guestfs_get_e2uuid (g, device);
3408   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3409   if (r == NULL) {
3410     throw_exception (env, guestfs_last_error (g));
3411     return NULL;
3412   }
3413   jr = (*env)->NewStringUTF (env, r);
3414   free (r);
3415   return jr;
3416 }
3417
3418 JNIEXPORT jint JNICALL
3419 Java_com_redhat_et_libguestfs_GuestFS__1fsck
3420   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
3421 {
3422   guestfs_h *g = (guestfs_h *) (long) jg;
3423   int r;
3424   const char *fstype;
3425   const char *device;
3426
3427   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
3428   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3429   r = guestfs_fsck (g, fstype, device);
3430   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
3431   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3432   if (r == -1) {
3433     throw_exception (env, guestfs_last_error (g));
3434     return 0;
3435   }
3436   return (jint) r;
3437 }
3438
3439 JNIEXPORT void JNICALL
3440 Java_com_redhat_et_libguestfs_GuestFS__1zero
3441   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3442 {
3443   guestfs_h *g = (guestfs_h *) (long) jg;
3444   int r;
3445   const char *device;
3446
3447   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3448   r = guestfs_zero (g, device);
3449   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3450   if (r == -1) {
3451     throw_exception (env, guestfs_last_error (g));
3452     return ;
3453   }
3454 }
3455
3456 JNIEXPORT void JNICALL
3457 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
3458   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
3459 {
3460   guestfs_h *g = (guestfs_h *) (long) jg;
3461   int r;
3462   const char *root;
3463   const char *device;
3464
3465   root = (*env)->GetStringUTFChars (env, jroot, NULL);
3466   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3467   r = guestfs_grub_install (g, root, device);
3468   (*env)->ReleaseStringUTFChars (env, jroot, root);
3469   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3470   if (r == -1) {
3471     throw_exception (env, guestfs_last_error (g));
3472     return ;
3473   }
3474 }
3475
3476 JNIEXPORT void JNICALL
3477 Java_com_redhat_et_libguestfs_GuestFS__1cp
3478   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3479 {
3480   guestfs_h *g = (guestfs_h *) (long) jg;
3481   int r;
3482   const char *src;
3483   const char *dest;
3484
3485   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3486   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3487   r = guestfs_cp (g, src, dest);
3488   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3489   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3490   if (r == -1) {
3491     throw_exception (env, guestfs_last_error (g));
3492     return ;
3493   }
3494 }
3495
3496 JNIEXPORT void JNICALL
3497 Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
3498   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3499 {
3500   guestfs_h *g = (guestfs_h *) (long) jg;
3501   int r;
3502   const char *src;
3503   const char *dest;
3504
3505   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3506   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3507   r = guestfs_cp_a (g, src, dest);
3508   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3509   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3510   if (r == -1) {
3511     throw_exception (env, guestfs_last_error (g));
3512     return ;
3513   }
3514 }
3515
3516 JNIEXPORT void JNICALL
3517 Java_com_redhat_et_libguestfs_GuestFS__1mv
3518   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3519 {
3520   guestfs_h *g = (guestfs_h *) (long) jg;
3521   int r;
3522   const char *src;
3523   const char *dest;
3524
3525   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3526   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3527   r = guestfs_mv (g, src, dest);
3528   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3529   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3530   if (r == -1) {
3531     throw_exception (env, guestfs_last_error (g));
3532     return ;
3533   }
3534 }
3535
3536 JNIEXPORT void JNICALL
3537 Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
3538   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
3539 {
3540   guestfs_h *g = (guestfs_h *) (long) jg;
3541   int r;
3542   int whattodrop;
3543
3544   whattodrop = jwhattodrop;
3545   r = guestfs_drop_caches (g, whattodrop);
3546   if (r == -1) {
3547     throw_exception (env, guestfs_last_error (g));
3548     return ;
3549   }
3550 }
3551
3552 JNIEXPORT jstring JNICALL
3553 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
3554   (JNIEnv *env, jobject obj, jlong jg)
3555 {
3556   guestfs_h *g = (guestfs_h *) (long) jg;
3557   jstring jr;
3558   char *r;
3559
3560   r = guestfs_dmesg (g);
3561   if (r == NULL) {
3562     throw_exception (env, guestfs_last_error (g));
3563     return NULL;
3564   }
3565   jr = (*env)->NewStringUTF (env, r);
3566   free (r);
3567   return jr;
3568 }
3569
3570 JNIEXPORT void JNICALL
3571 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
3572   (JNIEnv *env, jobject obj, jlong jg)
3573 {
3574   guestfs_h *g = (guestfs_h *) (long) jg;
3575   int r;
3576
3577   r = guestfs_ping_daemon (g);
3578   if (r == -1) {
3579     throw_exception (env, guestfs_last_error (g));
3580     return ;
3581   }
3582 }
3583
3584 JNIEXPORT jboolean JNICALL
3585 Java_com_redhat_et_libguestfs_GuestFS__1equal
3586   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
3587 {
3588   guestfs_h *g = (guestfs_h *) (long) jg;
3589   int r;
3590   const char *file1;
3591   const char *file2;
3592
3593   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
3594   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
3595   r = guestfs_equal (g, file1, file2);
3596   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
3597   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
3598   if (r == -1) {
3599     throw_exception (env, guestfs_last_error (g));
3600     return 0;
3601   }
3602   return (jboolean) r;
3603 }
3604
3605 JNIEXPORT jobjectArray JNICALL
3606 Java_com_redhat_et_libguestfs_GuestFS__1strings
3607   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3608 {
3609   guestfs_h *g = (guestfs_h *) (long) jg;
3610   jobjectArray jr;
3611   int r_len;
3612   jclass cl;
3613   jstring jstr;
3614   char **r;
3615   const char *path;
3616   int i;
3617
3618   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3619   r = guestfs_strings (g, path);
3620   (*env)->ReleaseStringUTFChars (env, jpath, path);
3621   if (r == NULL) {
3622     throw_exception (env, guestfs_last_error (g));
3623     return NULL;
3624   }
3625   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3626   cl = (*env)->FindClass (env, "java/lang/String");
3627   jstr = (*env)->NewStringUTF (env, "");
3628   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3629   for (i = 0; i < r_len; ++i) {
3630     jstr = (*env)->NewStringUTF (env, r[i]);
3631     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3632     free (r[i]);
3633   }
3634   free (r);
3635   return jr;
3636 }
3637
3638 JNIEXPORT jobjectArray JNICALL
3639 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
3640   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
3641 {
3642   guestfs_h *g = (guestfs_h *) (long) jg;
3643   jobjectArray jr;
3644   int r_len;
3645   jclass cl;
3646   jstring jstr;
3647   char **r;
3648   const char *encoding;
3649   const char *path;
3650   int i;
3651
3652   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
3653   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3654   r = guestfs_strings_e (g, encoding, path);
3655   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
3656   (*env)->ReleaseStringUTFChars (env, jpath, path);
3657   if (r == NULL) {
3658     throw_exception (env, guestfs_last_error (g));
3659     return NULL;
3660   }
3661   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3662   cl = (*env)->FindClass (env, "java/lang/String");
3663   jstr = (*env)->NewStringUTF (env, "");
3664   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3665   for (i = 0; i < r_len; ++i) {
3666     jstr = (*env)->NewStringUTF (env, r[i]);
3667     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3668     free (r[i]);
3669   }
3670   free (r);
3671   return jr;
3672 }
3673
3674 JNIEXPORT jstring JNICALL
3675 Java_com_redhat_et_libguestfs_GuestFS__1hexdump
3676   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3677 {
3678   guestfs_h *g = (guestfs_h *) (long) jg;
3679   jstring jr;
3680   char *r;
3681   const char *path;
3682
3683   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3684   r = guestfs_hexdump (g, path);
3685   (*env)->ReleaseStringUTFChars (env, jpath, path);
3686   if (r == NULL) {
3687     throw_exception (env, guestfs_last_error (g));
3688     return NULL;
3689   }
3690   jr = (*env)->NewStringUTF (env, r);
3691   free (r);
3692   return jr;
3693 }
3694
3695 JNIEXPORT void JNICALL
3696 Java_com_redhat_et_libguestfs_GuestFS__1zerofree
3697   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3698 {
3699   guestfs_h *g = (guestfs_h *) (long) jg;
3700   int r;
3701   const char *device;
3702
3703   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3704   r = guestfs_zerofree (g, device);
3705   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3706   if (r == -1) {
3707     throw_exception (env, guestfs_last_error (g));
3708     return ;
3709   }
3710 }
3711
3712 JNIEXPORT void JNICALL
3713 Java_com_redhat_et_libguestfs_GuestFS__1pvresize
3714   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3715 {
3716   guestfs_h *g = (guestfs_h *) (long) jg;
3717   int r;
3718   const char *device;
3719
3720   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3721   r = guestfs_pvresize (g, device);
3722   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3723   if (r == -1) {
3724     throw_exception (env, guestfs_last_error (g));
3725     return ;
3726   }
3727 }
3728
3729 JNIEXPORT void JNICALL
3730 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1N
3731   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jn, jint jcyls, jint jheads, jint jsectors, jstring jline)
3732 {
3733   guestfs_h *g = (guestfs_h *) (long) jg;
3734   int r;
3735   const char *device;
3736   int n;
3737   int cyls;
3738   int heads;
3739   int sectors;
3740   const char *line;
3741
3742   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3743   n = jn;
3744   cyls = jcyls;
3745   heads = jheads;
3746   sectors = jsectors;
3747   line = (*env)->GetStringUTFChars (env, jline, NULL);
3748   r = guestfs_sfdisk_N (g, device, n, cyls, heads, sectors, line);
3749   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3750   (*env)->ReleaseStringUTFChars (env, jline, line);
3751   if (r == -1) {
3752     throw_exception (env, guestfs_last_error (g));
3753     return ;
3754   }
3755 }
3756
3757 JNIEXPORT jstring JNICALL
3758 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1l
3759   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3760 {
3761   guestfs_h *g = (guestfs_h *) (long) jg;
3762   jstring jr;
3763   char *r;
3764   const char *device;
3765
3766   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3767   r = guestfs_sfdisk_l (g, device);
3768   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3769   if (r == NULL) {
3770     throw_exception (env, guestfs_last_error (g));
3771     return NULL;
3772   }
3773   jr = (*env)->NewStringUTF (env, r);
3774   free (r);
3775   return jr;
3776 }
3777
3778 JNIEXPORT jstring JNICALL
3779 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1kernel_1geometry
3780   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3781 {
3782   guestfs_h *g = (guestfs_h *) (long) jg;
3783   jstring jr;
3784   char *r;
3785   const char *device;
3786
3787   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3788   r = guestfs_sfdisk_kernel_geometry (g, device);
3789   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3790   if (r == NULL) {
3791     throw_exception (env, guestfs_last_error (g));
3792     return NULL;
3793   }
3794   jr = (*env)->NewStringUTF (env, r);
3795   free (r);
3796   return jr;
3797 }
3798
3799 JNIEXPORT jstring JNICALL
3800 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1disk_1geometry
3801   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3802 {
3803   guestfs_h *g = (guestfs_h *) (long) jg;
3804   jstring jr;
3805   char *r;
3806   const char *device;
3807
3808   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3809   r = guestfs_sfdisk_disk_geometry (g, device);
3810   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3811   if (r == NULL) {
3812     throw_exception (env, guestfs_last_error (g));
3813     return NULL;
3814   }
3815   jr = (*env)->NewStringUTF (env, r);
3816   free (r);
3817   return jr;
3818 }
3819
3820 JNIEXPORT void JNICALL
3821 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate_1all
3822   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate)
3823 {
3824   guestfs_h *g = (guestfs_h *) (long) jg;
3825   int r;
3826   int activate;
3827
3828   activate = jactivate;
3829   r = guestfs_vg_activate_all (g, activate);
3830   if (r == -1) {
3831     throw_exception (env, guestfs_last_error (g));
3832     return ;
3833   }
3834 }
3835
3836 JNIEXPORT void JNICALL
3837 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate
3838   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate, jobjectArray jvolgroups)
3839 {
3840   guestfs_h *g = (guestfs_h *) (long) jg;
3841   int r;
3842   int activate;
3843   int volgroups_len;
3844   const char **volgroups;
3845   int i;
3846
3847   activate = jactivate;
3848   volgroups_len = (*env)->GetArrayLength (env, jvolgroups);
3849   volgroups = guestfs_safe_malloc (g, sizeof (char *) * (volgroups_len+1));
3850   for (i = 0; i < volgroups_len; ++i) {
3851     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3852     volgroups[i] = (*env)->GetStringUTFChars (env, o, NULL);
3853   }
3854   volgroups[volgroups_len] = NULL;
3855   r = guestfs_vg_activate (g, activate, volgroups);
3856   for (i = 0; i < volgroups_len; ++i) {
3857     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3858     (*env)->ReleaseStringUTFChars (env, o, volgroups[i]);
3859   }
3860   free (volgroups);
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__1lvresize
3869   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jmbytes)
3870 {
3871   guestfs_h *g = (guestfs_h *) (long) jg;
3872   int r;
3873   const char *device;
3874   int mbytes;
3875
3876   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3877   mbytes = jmbytes;
3878   r = guestfs_lvresize (g, device, mbytes);
3879   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3880   if (r == -1) {
3881     throw_exception (env, guestfs_last_error (g));
3882     return ;
3883   }
3884 }
3885
3886 JNIEXPORT void JNICALL
3887 Java_com_redhat_et_libguestfs_GuestFS__1resize2fs
3888   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3889 {
3890   guestfs_h *g = (guestfs_h *) (long) jg;
3891   int r;
3892   const char *device;
3893
3894   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3895   r = guestfs_resize2fs (g, device);
3896   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3897   if (r == -1) {
3898     throw_exception (env, guestfs_last_error (g));
3899     return ;
3900   }
3901 }
3902
3903 JNIEXPORT jobjectArray JNICALL
3904 Java_com_redhat_et_libguestfs_GuestFS__1find
3905   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
3906 {
3907   guestfs_h *g = (guestfs_h *) (long) jg;
3908   jobjectArray jr;
3909   int r_len;
3910   jclass cl;
3911   jstring jstr;
3912   char **r;
3913   const char *directory;
3914   int i;
3915
3916   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3917   r = guestfs_find (g, directory);
3918   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3919   if (r == NULL) {
3920     throw_exception (env, guestfs_last_error (g));
3921     return NULL;
3922   }
3923   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3924   cl = (*env)->FindClass (env, "java/lang/String");
3925   jstr = (*env)->NewStringUTF (env, "");
3926   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3927   for (i = 0; i < r_len; ++i) {
3928     jstr = (*env)->NewStringUTF (env, r[i]);
3929     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3930     free (r[i]);
3931   }
3932   free (r);
3933   return jr;
3934 }
3935
3936 JNIEXPORT void JNICALL
3937 Java_com_redhat_et_libguestfs_GuestFS__1e2fsck_1f
3938   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3939 {
3940   guestfs_h *g = (guestfs_h *) (long) jg;
3941   int r;
3942   const char *device;
3943
3944   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3945   r = guestfs_e2fsck_f (g, device);
3946   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3947   if (r == -1) {
3948     throw_exception (env, guestfs_last_error (g));
3949     return ;
3950   }
3951 }
3952
3953 JNIEXPORT void JNICALL
3954 Java_com_redhat_et_libguestfs_GuestFS__1sleep
3955   (JNIEnv *env, jobject obj, jlong jg, jint jsecs)
3956 {
3957   guestfs_h *g = (guestfs_h *) (long) jg;
3958   int r;
3959   int secs;
3960
3961   secs = jsecs;
3962   r = guestfs_sleep (g, secs);
3963   if (r == -1) {
3964     throw_exception (env, guestfs_last_error (g));
3965     return ;
3966   }
3967 }
3968
3969 JNIEXPORT jint JNICALL
3970 Java_com_redhat_et_libguestfs_GuestFS__1ntfs_13g_1probe
3971   (JNIEnv *env, jobject obj, jlong jg, jboolean jrw, jstring jdevice)
3972 {
3973   guestfs_h *g = (guestfs_h *) (long) jg;
3974   int r;
3975   int rw;
3976   const char *device;
3977
3978   rw = jrw;
3979   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3980   r = guestfs_ntfs_3g_probe (g, rw, device);
3981   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3982   if (r == -1) {
3983     throw_exception (env, guestfs_last_error (g));
3984     return 0;
3985   }
3986   return (jint) r;
3987 }
3988
3989 JNIEXPORT jstring JNICALL
3990 Java_com_redhat_et_libguestfs_GuestFS__1sh
3991   (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
3992 {
3993   guestfs_h *g = (guestfs_h *) (long) jg;
3994   jstring jr;
3995   char *r;
3996   const char *command;
3997
3998   command = (*env)->GetStringUTFChars (env, jcommand, NULL);
3999   r = guestfs_sh (g, command);
4000   (*env)->ReleaseStringUTFChars (env, jcommand, command);
4001   if (r == NULL) {
4002     throw_exception (env, guestfs_last_error (g));
4003     return NULL;
4004   }
4005   jr = (*env)->NewStringUTF (env, r);
4006   free (r);
4007   return jr;
4008 }
4009
4010 JNIEXPORT jobjectArray JNICALL
4011 Java_com_redhat_et_libguestfs_GuestFS__1sh_1lines
4012   (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
4013 {
4014   guestfs_h *g = (guestfs_h *) (long) jg;
4015   jobjectArray jr;
4016   int r_len;
4017   jclass cl;
4018   jstring jstr;
4019   char **r;
4020   const char *command;
4021   int i;
4022
4023   command = (*env)->GetStringUTFChars (env, jcommand, NULL);
4024   r = guestfs_sh_lines (g, command);
4025   (*env)->ReleaseStringUTFChars (env, jcommand, command);
4026   if (r == NULL) {
4027     throw_exception (env, guestfs_last_error (g));
4028     return NULL;
4029   }
4030   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4031   cl = (*env)->FindClass (env, "java/lang/String");
4032   jstr = (*env)->NewStringUTF (env, "");
4033   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4034   for (i = 0; i < r_len; ++i) {
4035     jstr = (*env)->NewStringUTF (env, r[i]);
4036     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4037     free (r[i]);
4038   }
4039   free (r);
4040   return jr;
4041 }
4042