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