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__1launch
  66   (JNIEnv *env, jobject obj, jlong jg)
  67 {
  68   guestfs_h *g = (guestfs_h *) (long) jg;
  69   int r;
  70
  71   r = guestfs_launch (g);
  72   if (r == -1) {
  73     throw_exception (env, guestfs_last_error (g));
  74     return ;
  75   }
  76 }
  77
  78 JNIEXPORT void JNICALL
  79 Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
  80   (JNIEnv *env, jobject obj, jlong jg)
  81 {
  82   guestfs_h *g = (guestfs_h *) (long) jg;
  83   int r;
  84
  85   r = guestfs_wait_ready (g);
  86   if (r == -1) {
  87     throw_exception (env, guestfs_last_error (g));
  88     return ;
  89   }
  90 }
  91
  92 JNIEXPORT void JNICALL
  93 Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
  94   (JNIEnv *env, jobject obj, jlong jg)
  95 {
  96   guestfs_h *g = (guestfs_h *) (long) jg;
  97   int r;
  98
  99   r = guestfs_kill_subprocess (g);
 100   if (r == -1) {
 101     throw_exception (env, guestfs_last_error (g));
 102     return ;
 103   }
 104 }
 105
 106 JNIEXPORT void JNICALL
 107 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
 108   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
 109 {
 110   guestfs_h *g = (guestfs_h *) (long) jg;
 111   int r;
 112   const char *filename;
 113
 114   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
 115   r = guestfs_add_drive (g, filename);
 116   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
 117   if (r == -1) {
 118     throw_exception (env, guestfs_last_error (g));
 119     return ;
 120   }
 121 }
 122
 123 JNIEXPORT void JNICALL
 124 Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
 125   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
 126 {
 127   guestfs_h *g = (guestfs_h *) (long) jg;
 128   int r;
 129   const char *filename;
 130
 131   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
 132   r = guestfs_add_cdrom (g, filename);
 133   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
 134   if (r == -1) {
 135     throw_exception (env, guestfs_last_error (g));
 136     return ;
 137   }
 138 }
 139
 140 JNIEXPORT void JNICALL
 141 Java_com_redhat_et_libguestfs_GuestFS__1config
 142   (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
 143 {
 144   guestfs_h *g = (guestfs_h *) (long) jg;
 145   int r;
 146   const char *qemuparam;
 147   const char *qemuvalue;
 148
 149   qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
 150   qemuvalue = (*env)->GetStringUTFChars (env, jqemuvalue, NULL);
 151   r = guestfs_config (g, qemuparam, qemuvalue);
 152   (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
 153   (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
 154   if (r == -1) {
 155     throw_exception (env, guestfs_last_error (g));
 156     return ;
 157   }
 158 }
 159
 160 JNIEXPORT void JNICALL
 161 Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
 162   (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
 163 {
 164   guestfs_h *g = (guestfs_h *) (long) jg;
 165   int r;
 166   const char *qemu;
 167
 168   qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
 169   r = guestfs_set_qemu (g, qemu);
 170   (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
 171   if (r == -1) {
 172     throw_exception (env, guestfs_last_error (g));
 173     return ;
 174   }
 175 }
 176
 177 JNIEXPORT jstring JNICALL
 178 Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
 179   (JNIEnv *env, jobject obj, jlong jg)
 180 {
 181   guestfs_h *g = (guestfs_h *) (long) jg;
 182   const char *r;
 183
 184   r = guestfs_get_qemu (g);
 185   if (r == NULL) {
 186     throw_exception (env, guestfs_last_error (g));
 187     return NULL;
 188   }
 189   return (*env)->NewStringUTF (env, r);
 190 }
 191
 192 JNIEXPORT void JNICALL
 193 Java_com_redhat_et_libguestfs_GuestFS__1set_1path
 194   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 195 {
 196   guestfs_h *g = (guestfs_h *) (long) jg;
 197   int r;
 198   const char *path;
 199
 200   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 201   r = guestfs_set_path (g, path);
 202   (*env)->ReleaseStringUTFChars (env, jpath, path);
 203   if (r == -1) {
 204     throw_exception (env, guestfs_last_error (g));
 205     return ;
 206   }
 207 }
 208
 209 JNIEXPORT jstring JNICALL
 210 Java_com_redhat_et_libguestfs_GuestFS__1get_1path
 211   (JNIEnv *env, jobject obj, jlong jg)
 212 {
 213   guestfs_h *g = (guestfs_h *) (long) jg;
 214   const char *r;
 215
 216   r = guestfs_get_path (g);
 217   if (r == NULL) {
 218     throw_exception (env, guestfs_last_error (g));
 219     return NULL;
 220   }
 221   return (*env)->NewStringUTF (env, r);
 222 }
 223
 224 JNIEXPORT void JNICALL
 225 Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
 226   (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
 227 {
 228   guestfs_h *g = (guestfs_h *) (long) jg;
 229   int r;
 230   int autosync;
 231
 232   autosync = jautosync;
 233   r = guestfs_set_autosync (g, autosync);
 234   if (r == -1) {
 235     throw_exception (env, guestfs_last_error (g));
 236     return ;
 237   }
 238 }
 239
 240 JNIEXPORT jboolean JNICALL
 241 Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
 242   (JNIEnv *env, jobject obj, jlong jg)
 243 {
 244   guestfs_h *g = (guestfs_h *) (long) jg;
 245   int r;
 246
 247   r = guestfs_get_autosync (g);
 248   if (r == -1) {
 249     throw_exception (env, guestfs_last_error (g));
 250     return 0;
 251   }
 252   return (jboolean) r;
 253 }
 254
 255 JNIEXPORT void JNICALL
 256 Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
 257   (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
 258 {
 259   guestfs_h *g = (guestfs_h *) (long) jg;
 260   int r;
 261   int verbose;
 262
 263   verbose = jverbose;
 264   r = guestfs_set_verbose (g, verbose);
 265   if (r == -1) {
 266     throw_exception (env, guestfs_last_error (g));
 267     return ;
 268   }
 269 }
 270
 271 JNIEXPORT jboolean JNICALL
 272 Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
 273   (JNIEnv *env, jobject obj, jlong jg)
 274 {
 275   guestfs_h *g = (guestfs_h *) (long) jg;
 276   int r;
 277
 278   r = guestfs_get_verbose (g);
 279   if (r == -1) {
 280     throw_exception (env, guestfs_last_error (g));
 281     return 0;
 282   }
 283   return (jboolean) r;
 284 }
 285
 286 JNIEXPORT jboolean JNICALL
 287 Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
 288   (JNIEnv *env, jobject obj, jlong jg)
 289 {
 290   guestfs_h *g = (guestfs_h *) (long) jg;
 291   int r;
 292
 293   r = guestfs_is_ready (g);
 294   if (r == -1) {
 295     throw_exception (env, guestfs_last_error (g));
 296     return 0;
 297   }
 298   return (jboolean) r;
 299 }
 300
 301 JNIEXPORT jboolean JNICALL
 302 Java_com_redhat_et_libguestfs_GuestFS__1is_1config
 303   (JNIEnv *env, jobject obj, jlong jg)
 304 {
 305   guestfs_h *g = (guestfs_h *) (long) jg;
 306   int r;
 307
 308   r = guestfs_is_config (g);
 309   if (r == -1) {
 310     throw_exception (env, guestfs_last_error (g));
 311     return 0;
 312   }
 313   return (jboolean) r;
 314 }
 315
 316 JNIEXPORT jboolean JNICALL
 317 Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
 318   (JNIEnv *env, jobject obj, jlong jg)
 319 {
 320   guestfs_h *g = (guestfs_h *) (long) jg;
 321   int r;
 322
 323   r = guestfs_is_launching (g);
 324   if (r == -1) {
 325     throw_exception (env, guestfs_last_error (g));
 326     return 0;
 327   }
 328   return (jboolean) r;
 329 }
 330
 331 JNIEXPORT jboolean JNICALL
 332 Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
 333   (JNIEnv *env, jobject obj, jlong jg)
 334 {
 335   guestfs_h *g = (guestfs_h *) (long) jg;
 336   int r;
 337
 338   r = guestfs_is_busy (g);
 339   if (r == -1) {
 340     throw_exception (env, guestfs_last_error (g));
 341     return 0;
 342   }
 343   return (jboolean) r;
 344 }
 345
 346 JNIEXPORT jint JNICALL
 347 Java_com_redhat_et_libguestfs_GuestFS__1get_1state
 348   (JNIEnv *env, jobject obj, jlong jg)
 349 {
 350   guestfs_h *g = (guestfs_h *) (long) jg;
 351   int r;
 352
 353   r = guestfs_get_state (g);
 354   if (r == -1) {
 355     throw_exception (env, guestfs_last_error (g));
 356     return 0;
 357   }
 358   return (jint) r;
 359 }
 360
 361 JNIEXPORT void JNICALL
 362 Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
 363   (JNIEnv *env, jobject obj, jlong jg)
 364 {
 365   guestfs_h *g = (guestfs_h *) (long) jg;
 366   int r;
 367
 368   r = guestfs_set_busy (g);
 369   if (r == -1) {
 370     throw_exception (env, guestfs_last_error (g));
 371     return ;
 372   }
 373 }
 374
 375 JNIEXPORT void JNICALL
 376 Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
 377   (JNIEnv *env, jobject obj, jlong jg)
 378 {
 379   guestfs_h *g = (guestfs_h *) (long) jg;
 380   int r;
 381
 382   r = guestfs_set_ready (g);
 383   if (r == -1) {
 384     throw_exception (env, guestfs_last_error (g));
 385     return ;
 386   }
 387 }
 388
 389 JNIEXPORT void JNICALL
 390 Java_com_redhat_et_libguestfs_GuestFS__1mount
 391   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
 392 {
 393   guestfs_h *g = (guestfs_h *) (long) jg;
 394   int r;
 395   const char *device;
 396   const char *mountpoint;
 397
 398   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
 399   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
 400   r = guestfs_mount (g, device, mountpoint);
 401   (*env)->ReleaseStringUTFChars (env, jdevice, device);
 402   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
 403   if (r == -1) {
 404     throw_exception (env, guestfs_last_error (g));
 405     return ;
 406   }
 407 }
 408
 409 JNIEXPORT void JNICALL
 410 Java_com_redhat_et_libguestfs_GuestFS__1sync
 411   (JNIEnv *env, jobject obj, jlong jg)
 412 {
 413   guestfs_h *g = (guestfs_h *) (long) jg;
 414   int r;
 415
 416   r = guestfs_sync (g);
 417   if (r == -1) {
 418     throw_exception (env, guestfs_last_error (g));
 419     return ;
 420   }
 421 }
 422
 423 JNIEXPORT void JNICALL
 424 Java_com_redhat_et_libguestfs_GuestFS__1touch
 425   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 426 {
 427   guestfs_h *g = (guestfs_h *) (long) jg;
 428   int r;
 429   const char *path;
 430
 431   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 432   r = guestfs_touch (g, path);
 433   (*env)->ReleaseStringUTFChars (env, jpath, path);
 434   if (r == -1) {
 435     throw_exception (env, guestfs_last_error (g));
 436     return ;
 437   }
 438 }
 439
 440 JNIEXPORT jstring JNICALL
 441 Java_com_redhat_et_libguestfs_GuestFS__1cat
 442   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 443 {
 444   guestfs_h *g = (guestfs_h *) (long) jg;
 445   jstring jr;
 446   char *r;
 447   const char *path;
 448
 449   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 450   r = guestfs_cat (g, path);
 451   (*env)->ReleaseStringUTFChars (env, jpath, path);
 452   if (r == NULL) {
 453     throw_exception (env, guestfs_last_error (g));
 454     return NULL;
 455   }
 456   jr = (*env)->NewStringUTF (env, r);
 457   free (r);
 458   return jr;
 459 }
 460
 461 JNIEXPORT jstring JNICALL
 462 Java_com_redhat_et_libguestfs_GuestFS__1ll
 463   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
 464 {
 465   guestfs_h *g = (guestfs_h *) (long) jg;
 466   jstring jr;
 467   char *r;
 468   const char *directory;
 469
 470   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
 471   r = guestfs_ll (g, directory);
 472   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
 473   if (r == NULL) {
 474     throw_exception (env, guestfs_last_error (g));
 475     return NULL;
 476   }
 477   jr = (*env)->NewStringUTF (env, r);
 478   free (r);
 479   return jr;
 480 }
 481
 482 JNIEXPORT jobjectArray JNICALL
 483 Java_com_redhat_et_libguestfs_GuestFS__1ls
 484   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
 485 {
 486   guestfs_h *g = (guestfs_h *) (long) jg;
 487   jobjectArray jr;
 488   int r_len;
 489   jclass cl;
 490   jstring jstr;
 491   char **r;
 492   const char *directory;
 493   int i;
 494
 495   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
 496   r = guestfs_ls (g, directory);
 497   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
 498   if (r == NULL) {
 499     throw_exception (env, guestfs_last_error (g));
 500     return NULL;
 501   }
 502   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 503   cl = (*env)->FindClass (env, "java/lang/String");
 504   jstr = (*env)->NewStringUTF (env, "");
 505   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 506   for (i = 0; i < r_len; ++i) {
 507     jstr = (*env)->NewStringUTF (env, r[i]);
 508     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 509     free (r[i]);
 510   }
 511   free (r);
 512   return jr;
 513 }
 514
 515 JNIEXPORT jobjectArray JNICALL
 516 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
 517   (JNIEnv *env, jobject obj, jlong jg)
 518 {
 519   guestfs_h *g = (guestfs_h *) (long) jg;
 520   jobjectArray jr;
 521   int r_len;
 522   jclass cl;
 523   jstring jstr;
 524   char **r;
 525   int i;
 526
 527   r = guestfs_list_devices (g);
 528   if (r == NULL) {
 529     throw_exception (env, guestfs_last_error (g));
 530     return NULL;
 531   }
 532   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 533   cl = (*env)->FindClass (env, "java/lang/String");
 534   jstr = (*env)->NewStringUTF (env, "");
 535   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 536   for (i = 0; i < r_len; ++i) {
 537     jstr = (*env)->NewStringUTF (env, r[i]);
 538     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 539     free (r[i]);
 540   }
 541   free (r);
 542   return jr;
 543 }
 544
 545 JNIEXPORT jobjectArray JNICALL
 546 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
 547   (JNIEnv *env, jobject obj, jlong jg)
 548 {
 549   guestfs_h *g = (guestfs_h *) (long) jg;
 550   jobjectArray jr;
 551   int r_len;
 552   jclass cl;
 553   jstring jstr;
 554   char **r;
 555   int i;
 556
 557   r = guestfs_list_partitions (g);
 558   if (r == NULL) {
 559     throw_exception (env, guestfs_last_error (g));
 560     return NULL;
 561   }
 562   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 563   cl = (*env)->FindClass (env, "java/lang/String");
 564   jstr = (*env)->NewStringUTF (env, "");
 565   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 566   for (i = 0; i < r_len; ++i) {
 567     jstr = (*env)->NewStringUTF (env, r[i]);
 568     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 569     free (r[i]);
 570   }
 571   free (r);
 572   return jr;
 573 }
 574
 575 JNIEXPORT jobjectArray JNICALL
 576 Java_com_redhat_et_libguestfs_GuestFS__1pvs
 577   (JNIEnv *env, jobject obj, jlong jg)
 578 {
 579   guestfs_h *g = (guestfs_h *) (long) jg;
 580   jobjectArray jr;
 581   int r_len;
 582   jclass cl;
 583   jstring jstr;
 584   char **r;
 585   int i;
 586
 587   r = guestfs_pvs (g);
 588   if (r == NULL) {
 589     throw_exception (env, guestfs_last_error (g));
 590     return NULL;
 591   }
 592   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 593   cl = (*env)->FindClass (env, "java/lang/String");
 594   jstr = (*env)->NewStringUTF (env, "");
 595   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 596   for (i = 0; i < r_len; ++i) {
 597     jstr = (*env)->NewStringUTF (env, r[i]);
 598     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 599     free (r[i]);
 600   }
 601   free (r);
 602   return jr;
 603 }
 604
 605 JNIEXPORT jobjectArray JNICALL
 606 Java_com_redhat_et_libguestfs_GuestFS__1vgs
 607   (JNIEnv *env, jobject obj, jlong jg)
 608 {
 609   guestfs_h *g = (guestfs_h *) (long) jg;
 610   jobjectArray jr;
 611   int r_len;
 612   jclass cl;
 613   jstring jstr;
 614   char **r;
 615   int i;
 616
 617   r = guestfs_vgs (g);
 618   if (r == NULL) {
 619     throw_exception (env, guestfs_last_error (g));
 620     return NULL;
 621   }
 622   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 623   cl = (*env)->FindClass (env, "java/lang/String");
 624   jstr = (*env)->NewStringUTF (env, "");
 625   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 626   for (i = 0; i < r_len; ++i) {
 627     jstr = (*env)->NewStringUTF (env, r[i]);
 628     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 629     free (r[i]);
 630   }
 631   free (r);
 632   return jr;
 633 }
 634
 635 JNIEXPORT jobjectArray JNICALL
 636 Java_com_redhat_et_libguestfs_GuestFS__1lvs
 637   (JNIEnv *env, jobject obj, jlong jg)
 638 {
 639   guestfs_h *g = (guestfs_h *) (long) jg;
 640   jobjectArray jr;
 641   int r_len;
 642   jclass cl;
 643   jstring jstr;
 644   char **r;
 645   int i;
 646
 647   r = guestfs_lvs (g);
 648   if (r == NULL) {
 649     throw_exception (env, guestfs_last_error (g));
 650     return NULL;
 651   }
 652   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 653   cl = (*env)->FindClass (env, "java/lang/String");
 654   jstr = (*env)->NewStringUTF (env, "");
 655   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 656   for (i = 0; i < r_len; ++i) {
 657     jstr = (*env)->NewStringUTF (env, r[i]);
 658     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 659     free (r[i]);
 660   }
 661   free (r);
 662   return jr;
 663 }
 664
 665 JNIEXPORT jobjectArray JNICALL
 666 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
 667   (JNIEnv *env, jobject obj, jlong jg)
 668 {
 669   guestfs_h *g = (guestfs_h *) (long) jg;
 670   jobjectArray jr;
 671   jclass cl;
 672   jfieldID fl;
 673   jobject jfl;
 674   struct guestfs_lvm_pv_list *r;
 675   int i;
 676
 677   r = guestfs_pvs_full (g);
 678   if (r == NULL) {
 679     throw_exception (env, guestfs_last_error (g));
 680     return NULL;
 681   }
 682   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 683   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 684   for (i = 0; i < r->len; ++i) {
 685     jfl = (*env)->AllocObject (env, cl);
 686     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 687     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 688     {
 689       char s[33];
 690       memcpy (s, r->val[i].pv_uuid, 32);
 691       s[32] = 0;
 692       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 693       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 694     }
 695     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 696     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 697     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 698     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 699     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 700     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 701     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 702     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 703     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 704     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 705     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 706     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 707     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 708     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 709     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 710     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 711     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 712     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 713     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 714     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 715     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 716     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 717     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 718     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 719     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 720   }
 721   guestfs_free_lvm_pv_list (r);
 722   return jr;
 723 }
 724
 725 JNIEXPORT jobjectArray JNICALL
 726 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
 727   (JNIEnv *env, jobject obj, jlong jg)
 728 {
 729   guestfs_h *g = (guestfs_h *) (long) jg;
 730   jobjectArray jr;
 731   jclass cl;
 732   jfieldID fl;
 733   jobject jfl;
 734   struct guestfs_lvm_vg_list *r;
 735   int i;
 736
 737   r = guestfs_vgs_full (g);
 738   if (r == NULL) {
 739     throw_exception (env, guestfs_last_error (g));
 740     return NULL;
 741   }
 742   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 743   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 744   for (i = 0; i < r->len; ++i) {
 745     jfl = (*env)->AllocObject (env, cl);
 746     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 747     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 748     {
 749       char s[33];
 750       memcpy (s, r->val[i].vg_uuid, 32);
 751       s[32] = 0;
 752       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 753       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 754     }
 755     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 756     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 757     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 758     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 759     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 760     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 761     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 762     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 763     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 764     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 765     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 766     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 767     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 768     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 769     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 770     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 771     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 772     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 773     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 774     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 775     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 776     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 777     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 778     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 779     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 780     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 781     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 782     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 783     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 784     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 785     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 786     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 787     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 788     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 789     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 790   }
 791   guestfs_free_lvm_vg_list (r);
 792   return jr;
 793 }
 794
 795 JNIEXPORT jobjectArray JNICALL
 796 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
 797   (JNIEnv *env, jobject obj, jlong jg)
 798 {
 799   guestfs_h *g = (guestfs_h *) (long) jg;
 800   jobjectArray jr;
 801   jclass cl;
 802   jfieldID fl;
 803   jobject jfl;
 804   struct guestfs_lvm_lv_list *r;
 805   int i;
 806
 807   r = guestfs_lvs_full (g);
 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/LV");
 813   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 814   for (i = 0; i < r->len; ++i) {
 815     jfl = (*env)->AllocObject (env, cl);
 816     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 817     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 818     {
 819       char s[33];
 820       memcpy (s, r->val[i].lv_uuid, 32);
 821       s[32] = 0;
 822       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 823       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 824     }
 825     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 826     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 827     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 828     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 829     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 830     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 831     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 832     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 833     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 834     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 835     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 836     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 837     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 838     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 839     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 840     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 841     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 842     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 843     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 844     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 845     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 846     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 847     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 848     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 849     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 850     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 851     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 852     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 853     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 854   }
 855   guestfs_free_lvm_lv_list (r);
 856   return jr;
 857 }
 858
 859 JNIEXPORT jobjectArray JNICALL
 860 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
 861   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 862 {
 863   guestfs_h *g = (guestfs_h *) (long) jg;
 864   jobjectArray jr;
 865   int r_len;
 866   jclass cl;
 867   jstring jstr;
 868   char **r;
 869   const char *path;
 870   int i;
 871
 872   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 873   r = guestfs_read_lines (g, path);
 874   (*env)->ReleaseStringUTFChars (env, jpath, path);
 875   if (r == NULL) {
 876     throw_exception (env, guestfs_last_error (g));
 877     return NULL;
 878   }
 879   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 880   cl = (*env)->FindClass (env, "java/lang/String");
 881   jstr = (*env)->NewStringUTF (env, "");
 882   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 883   for (i = 0; i < r_len; ++i) {
 884     jstr = (*env)->NewStringUTF (env, r[i]);
 885     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 886     free (r[i]);
 887   }
 888   free (r);
 889   return jr;
 890 }
 891
 892 JNIEXPORT void JNICALL
 893 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
 894   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
 895 {
 896   guestfs_h *g = (guestfs_h *) (long) jg;
 897   int r;
 898   const char *root;
 899   int flags;
 900
 901   root = (*env)->GetStringUTFChars (env, jroot, NULL);
 902   flags = jflags;
 903   r = guestfs_aug_init (g, root, flags);
 904   (*env)->ReleaseStringUTFChars (env, jroot, root);
 905   if (r == -1) {
 906     throw_exception (env, guestfs_last_error (g));
 907     return ;
 908   }
 909 }
 910
 911 JNIEXPORT void JNICALL
 912 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
 913   (JNIEnv *env, jobject obj, jlong jg)
 914 {
 915   guestfs_h *g = (guestfs_h *) (long) jg;
 916   int r;
 917
 918   r = guestfs_aug_close (g);
 919   if (r == -1) {
 920     throw_exception (env, guestfs_last_error (g));
 921     return ;
 922   }
 923 }
 924
 925 JNIEXPORT jint JNICALL
 926 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
 927   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
 928 {
 929   guestfs_h *g = (guestfs_h *) (long) jg;
 930   int r;
 931   const char *name;
 932   const char *expr;
 933
 934   name = (*env)->GetStringUTFChars (env, jname, NULL);
 935   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
 936   r = guestfs_aug_defvar (g, name, expr);
 937   (*env)->ReleaseStringUTFChars (env, jname, name);
 938   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
 939   if (r == -1) {
 940     throw_exception (env, guestfs_last_error (g));
 941     return 0;
 942   }
 943   return (jint) r;
 944 }
 945
 946 JNIEXPORT jobject JNICALL
 947 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
 948   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
 949 {
 950   guestfs_h *g = (guestfs_h *) (long) jg;
 951   jobject jr;
 952   jclass cl;
 953   jfieldID fl;
 954   struct guestfs_int_bool *r;
 955   const char *name;
 956   const char *expr;
 957   const char *val;
 958
 959   name = (*env)->GetStringUTFChars (env, jname, NULL);
 960   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
 961   val = (*env)->GetStringUTFChars (env, jval, NULL);
 962   r = guestfs_aug_defnode (g, name, expr, val);
 963   (*env)->ReleaseStringUTFChars (env, jname, name);
 964   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
 965   (*env)->ReleaseStringUTFChars (env, jval, val);
 966   if (r == NULL) {
 967     throw_exception (env, guestfs_last_error (g));
 968     return NULL;
 969   }
 970   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 971   jr = (*env)->AllocObject (env, cl);
 972   fl = (*env)->GetFieldID (env, cl, "i", "I");
 973   (*env)->SetIntField (env, jr, fl, r->i);
 974   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 975   (*env)->SetBooleanField (env, jr, fl, r->b);
 976   guestfs_free_int_bool (r);
 977   return jr;
 978 }
 979
 980 JNIEXPORT jstring JNICALL
 981 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
 982   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 983 {
 984   guestfs_h *g = (guestfs_h *) (long) jg;
 985   jstring jr;
 986   char *r;
 987   const char *path;
 988
 989   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 990   r = guestfs_aug_get (g, path);
 991   (*env)->ReleaseStringUTFChars (env, jpath, path);
 992   if (r == NULL) {
 993     throw_exception (env, guestfs_last_error (g));
 994     return NULL;
 995   }
 996   jr = (*env)->NewStringUTF (env, r);
 997   free (r);
 998   return jr;
 999 }
1000
1001 JNIEXPORT void JNICALL
1002 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
1003   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
1004 {
1005   guestfs_h *g = (guestfs_h *) (long) jg;
1006   int r;
1007   const char *path;
1008   const char *val;
1009
1010   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1011   val = (*env)->GetStringUTFChars (env, jval, NULL);
1012   r = guestfs_aug_set (g, path, val);
1013   (*env)->ReleaseStringUTFChars (env, jpath, path);
1014   (*env)->ReleaseStringUTFChars (env, jval, val);
1015   if (r == -1) {
1016     throw_exception (env, guestfs_last_error (g));
1017     return ;
1018   }
1019 }
1020
1021 JNIEXPORT void JNICALL
1022 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
1023   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
1024 {
1025   guestfs_h *g = (guestfs_h *) (long) jg;
1026   int r;
1027   const char *path;
1028   const char *label;
1029   int before;
1030
1031   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1032   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
1033   before = jbefore;
1034   r = guestfs_aug_insert (g, path, label, before);
1035   (*env)->ReleaseStringUTFChars (env, jpath, path);
1036   (*env)->ReleaseStringUTFChars (env, jlabel, label);
1037   if (r == -1) {
1038     throw_exception (env, guestfs_last_error (g));
1039     return ;
1040   }
1041 }
1042
1043 JNIEXPORT jint JNICALL
1044 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
1045   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1046 {
1047   guestfs_h *g = (guestfs_h *) (long) jg;
1048   int r;
1049   const char *path;
1050
1051   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1052   r = guestfs_aug_rm (g, path);
1053   (*env)->ReleaseStringUTFChars (env, jpath, path);
1054   if (r == -1) {
1055     throw_exception (env, guestfs_last_error (g));
1056     return 0;
1057   }
1058   return (jint) r;
1059 }
1060
1061 JNIEXPORT void JNICALL
1062 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
1063   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
1064 {
1065   guestfs_h *g = (guestfs_h *) (long) jg;
1066   int r;
1067   const char *src;
1068   const char *dest;
1069
1070   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
1071   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
1072   r = guestfs_aug_mv (g, src, dest);
1073   (*env)->ReleaseStringUTFChars (env, jsrc, src);
1074   (*env)->ReleaseStringUTFChars (env, jdest, dest);
1075   if (r == -1) {
1076     throw_exception (env, guestfs_last_error (g));
1077     return ;
1078   }
1079 }
1080
1081 JNIEXPORT jobjectArray JNICALL
1082 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
1083   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1084 {
1085   guestfs_h *g = (guestfs_h *) (long) jg;
1086   jobjectArray jr;
1087   int r_len;
1088   jclass cl;
1089   jstring jstr;
1090   char **r;
1091   const char *path;
1092   int i;
1093
1094   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1095   r = guestfs_aug_match (g, path);
1096   (*env)->ReleaseStringUTFChars (env, jpath, path);
1097   if (r == NULL) {
1098     throw_exception (env, guestfs_last_error (g));
1099     return NULL;
1100   }
1101   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1102   cl = (*env)->FindClass (env, "java/lang/String");
1103   jstr = (*env)->NewStringUTF (env, "");
1104   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1105   for (i = 0; i < r_len; ++i) {
1106     jstr = (*env)->NewStringUTF (env, r[i]);
1107     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1108     free (r[i]);
1109   }
1110   free (r);
1111   return jr;
1112 }
1113
1114 JNIEXPORT void JNICALL
1115 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
1116   (JNIEnv *env, jobject obj, jlong jg)
1117 {
1118   guestfs_h *g = (guestfs_h *) (long) jg;
1119   int r;
1120
1121   r = guestfs_aug_save (g);
1122   if (r == -1) {
1123     throw_exception (env, guestfs_last_error (g));
1124     return ;
1125   }
1126 }
1127
1128 JNIEXPORT void JNICALL
1129 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
1130   (JNIEnv *env, jobject obj, jlong jg)
1131 {
1132   guestfs_h *g = (guestfs_h *) (long) jg;
1133   int r;
1134
1135   r = guestfs_aug_load (g);
1136   if (r == -1) {
1137     throw_exception (env, guestfs_last_error (g));
1138     return ;
1139   }
1140 }
1141
1142 JNIEXPORT jobjectArray JNICALL
1143 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
1144   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1145 {
1146   guestfs_h *g = (guestfs_h *) (long) jg;
1147   jobjectArray jr;
1148   int r_len;
1149   jclass cl;
1150   jstring jstr;
1151   char **r;
1152   const char *path;
1153   int i;
1154
1155   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1156   r = guestfs_aug_ls (g, path);
1157   (*env)->ReleaseStringUTFChars (env, jpath, path);
1158   if (r == NULL) {
1159     throw_exception (env, guestfs_last_error (g));
1160     return NULL;
1161   }
1162   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1163   cl = (*env)->FindClass (env, "java/lang/String");
1164   jstr = (*env)->NewStringUTF (env, "");
1165   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1166   for (i = 0; i < r_len; ++i) {
1167     jstr = (*env)->NewStringUTF (env, r[i]);
1168     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1169     free (r[i]);
1170   }
1171   free (r);
1172   return jr;
1173 }
1174
1175 JNIEXPORT void JNICALL
1176 Java_com_redhat_et_libguestfs_GuestFS__1rm
1177   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1178 {
1179   guestfs_h *g = (guestfs_h *) (long) jg;
1180   int r;
1181   const char *path;
1182
1183   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1184   r = guestfs_rm (g, path);
1185   (*env)->ReleaseStringUTFChars (env, jpath, path);
1186   if (r == -1) {
1187     throw_exception (env, guestfs_last_error (g));
1188     return ;
1189   }
1190 }
1191
1192 JNIEXPORT void JNICALL
1193 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
1194   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1195 {
1196   guestfs_h *g = (guestfs_h *) (long) jg;
1197   int r;
1198   const char *path;
1199
1200   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1201   r = guestfs_rmdir (g, path);
1202   (*env)->ReleaseStringUTFChars (env, jpath, path);
1203   if (r == -1) {
1204     throw_exception (env, guestfs_last_error (g));
1205     return ;
1206   }
1207 }
1208
1209 JNIEXPORT void JNICALL
1210 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
1211   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1212 {
1213   guestfs_h *g = (guestfs_h *) (long) jg;
1214   int r;
1215   const char *path;
1216
1217   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1218   r = guestfs_rm_rf (g, path);
1219   (*env)->ReleaseStringUTFChars (env, jpath, path);
1220   if (r == -1) {
1221     throw_exception (env, guestfs_last_error (g));
1222     return ;
1223   }
1224 }
1225
1226 JNIEXPORT void JNICALL
1227 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
1228   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1229 {
1230   guestfs_h *g = (guestfs_h *) (long) jg;
1231   int r;
1232   const char *path;
1233
1234   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1235   r = guestfs_mkdir (g, path);
1236   (*env)->ReleaseStringUTFChars (env, jpath, path);
1237   if (r == -1) {
1238     throw_exception (env, guestfs_last_error (g));
1239     return ;
1240   }
1241 }
1242
1243 JNIEXPORT void JNICALL
1244 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
1245   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1246 {
1247   guestfs_h *g = (guestfs_h *) (long) jg;
1248   int r;
1249   const char *path;
1250
1251   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1252   r = guestfs_mkdir_p (g, path);
1253   (*env)->ReleaseStringUTFChars (env, jpath, path);
1254   if (r == -1) {
1255     throw_exception (env, guestfs_last_error (g));
1256     return ;
1257   }
1258 }
1259
1260 JNIEXPORT void JNICALL
1261 Java_com_redhat_et_libguestfs_GuestFS__1chmod
1262   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
1263 {
1264   guestfs_h *g = (guestfs_h *) (long) jg;
1265   int r;
1266   int mode;
1267   const char *path;
1268
1269   mode = jmode;
1270   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1271   r = guestfs_chmod (g, mode, path);
1272   (*env)->ReleaseStringUTFChars (env, jpath, path);
1273   if (r == -1) {
1274     throw_exception (env, guestfs_last_error (g));
1275     return ;
1276   }
1277 }
1278
1279 JNIEXPORT void JNICALL
1280 Java_com_redhat_et_libguestfs_GuestFS__1chown
1281   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
1282 {
1283   guestfs_h *g = (guestfs_h *) (long) jg;
1284   int r;
1285   int owner;
1286   int group;
1287   const char *path;
1288
1289   owner = jowner;
1290   group = jgroup;
1291   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1292   r = guestfs_chown (g, owner, group, path);
1293   (*env)->ReleaseStringUTFChars (env, jpath, path);
1294   if (r == -1) {
1295     throw_exception (env, guestfs_last_error (g));
1296     return ;
1297   }
1298 }
1299
1300 JNIEXPORT jboolean JNICALL
1301 Java_com_redhat_et_libguestfs_GuestFS__1exists
1302   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1303 {
1304   guestfs_h *g = (guestfs_h *) (long) jg;
1305   int r;
1306   const char *path;
1307
1308   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1309   r = guestfs_exists (g, path);
1310   (*env)->ReleaseStringUTFChars (env, jpath, path);
1311   if (r == -1) {
1312     throw_exception (env, guestfs_last_error (g));
1313     return 0;
1314   }
1315   return (jboolean) r;
1316 }
1317
1318 JNIEXPORT jboolean JNICALL
1319 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
1320   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1321 {
1322   guestfs_h *g = (guestfs_h *) (long) jg;
1323   int r;
1324   const char *path;
1325
1326   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1327   r = guestfs_is_file (g, path);
1328   (*env)->ReleaseStringUTFChars (env, jpath, path);
1329   if (r == -1) {
1330     throw_exception (env, guestfs_last_error (g));
1331     return 0;
1332   }
1333   return (jboolean) r;
1334 }
1335
1336 JNIEXPORT jboolean JNICALL
1337 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
1338   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1339 {
1340   guestfs_h *g = (guestfs_h *) (long) jg;
1341   int r;
1342   const char *path;
1343
1344   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1345   r = guestfs_is_dir (g, path);
1346   (*env)->ReleaseStringUTFChars (env, jpath, path);
1347   if (r == -1) {
1348     throw_exception (env, guestfs_last_error (g));
1349     return 0;
1350   }
1351   return (jboolean) r;
1352 }
1353
1354 JNIEXPORT void JNICALL
1355 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
1356   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1357 {
1358   guestfs_h *g = (guestfs_h *) (long) jg;
1359   int r;
1360   const char *device;
1361
1362   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1363   r = guestfs_pvcreate (g, device);
1364   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1365   if (r == -1) {
1366     throw_exception (env, guestfs_last_error (g));
1367     return ;
1368   }
1369 }
1370
1371 JNIEXPORT void JNICALL
1372 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
1373   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
1374 {
1375   guestfs_h *g = (guestfs_h *) (long) jg;
1376   int r;
1377   const char *volgroup;
1378   int physvols_len;
1379   const char **physvols;
1380   int i;
1381
1382   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
1383   physvols_len = (*env)->GetArrayLength (env, jphysvols);
1384   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
1385   for (i = 0; i < physvols_len; ++i) {
1386     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
1387     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
1388   }
1389   physvols[physvols_len] = NULL;
1390   r = guestfs_vgcreate (g, volgroup, physvols);
1391   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
1392   for (i = 0; i < physvols_len; ++i) {
1393     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
1394     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
1395   }
1396   free (physvols);
1397   if (r == -1) {
1398     throw_exception (env, guestfs_last_error (g));
1399     return ;
1400   }
1401 }
1402
1403 JNIEXPORT void JNICALL
1404 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
1405   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
1406 {
1407   guestfs_h *g = (guestfs_h *) (long) jg;
1408   int r;
1409   const char *logvol;
1410   const char *volgroup;
1411   int mbytes;
1412
1413   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
1414   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
1415   mbytes = jmbytes;
1416   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1417   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
1418   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
1419   if (r == -1) {
1420     throw_exception (env, guestfs_last_error (g));
1421     return ;
1422   }
1423 }
1424
1425 JNIEXPORT void JNICALL
1426 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
1427   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
1428 {
1429   guestfs_h *g = (guestfs_h *) (long) jg;
1430   int r;
1431   const char *fstype;
1432   const char *device;
1433
1434   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
1435   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1436   r = guestfs_mkfs (g, fstype, device);
1437   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
1438   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1439   if (r == -1) {
1440     throw_exception (env, guestfs_last_error (g));
1441     return ;
1442   }
1443 }
1444
1445 JNIEXPORT void JNICALL
1446 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
1447   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
1448 {
1449   guestfs_h *g = (guestfs_h *) (long) jg;
1450   int r;
1451   const char *device;
1452   int cyls;
1453   int heads;
1454   int sectors;
1455   int lines_len;
1456   const char **lines;
1457   int i;
1458
1459   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1460   cyls = jcyls;
1461   heads = jheads;
1462   sectors = jsectors;
1463   lines_len = (*env)->GetArrayLength (env, jlines);
1464   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
1465   for (i = 0; i < lines_len; ++i) {
1466     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
1467     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
1468   }
1469   lines[lines_len] = NULL;
1470   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1471   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1472   for (i = 0; i < lines_len; ++i) {
1473     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
1474     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
1475   }
1476   free (lines);
1477   if (r == -1) {
1478     throw_exception (env, guestfs_last_error (g));
1479     return ;
1480   }
1481 }
1482
1483 JNIEXPORT void JNICALL
1484 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
1485   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
1486 {
1487   guestfs_h *g = (guestfs_h *) (long) jg;
1488   int r;
1489   const char *path;
1490   const char *content;
1491   int size;
1492
1493   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1494   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
1495   size = jsize;
1496   r = guestfs_write_file (g, path, content, size);
1497   (*env)->ReleaseStringUTFChars (env, jpath, path);
1498   (*env)->ReleaseStringUTFChars (env, jcontent, content);
1499   if (r == -1) {
1500     throw_exception (env, guestfs_last_error (g));
1501     return ;
1502   }
1503 }
1504
1505 JNIEXPORT void JNICALL
1506 Java_com_redhat_et_libguestfs_GuestFS__1umount
1507   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
1508 {
1509   guestfs_h *g = (guestfs_h *) (long) jg;
1510   int r;
1511   const char *pathordevice;
1512
1513   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
1514   r = guestfs_umount (g, pathordevice);
1515   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
1516   if (r == -1) {
1517     throw_exception (env, guestfs_last_error (g));
1518     return ;
1519   }
1520 }
1521
1522 JNIEXPORT jobjectArray JNICALL
1523 Java_com_redhat_et_libguestfs_GuestFS__1mounts
1524   (JNIEnv *env, jobject obj, jlong jg)
1525 {
1526   guestfs_h *g = (guestfs_h *) (long) jg;
1527   jobjectArray jr;
1528   int r_len;
1529   jclass cl;
1530   jstring jstr;
1531   char **r;
1532   int i;
1533
1534   r = guestfs_mounts (g);
1535   if (r == NULL) {
1536     throw_exception (env, guestfs_last_error (g));
1537     return NULL;
1538   }
1539   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1540   cl = (*env)->FindClass (env, "java/lang/String");
1541   jstr = (*env)->NewStringUTF (env, "");
1542   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1543   for (i = 0; i < r_len; ++i) {
1544     jstr = (*env)->NewStringUTF (env, r[i]);
1545     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1546     free (r[i]);
1547   }
1548   free (r);
1549   return jr;
1550 }
1551
1552 JNIEXPORT void JNICALL
1553 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
1554   (JNIEnv *env, jobject obj, jlong jg)
1555 {
1556   guestfs_h *g = (guestfs_h *) (long) jg;
1557   int r;
1558
1559   r = guestfs_umount_all (g);
1560   if (r == -1) {
1561     throw_exception (env, guestfs_last_error (g));
1562     return ;
1563   }
1564 }
1565
1566 JNIEXPORT void JNICALL
1567 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
1568   (JNIEnv *env, jobject obj, jlong jg)
1569 {
1570   guestfs_h *g = (guestfs_h *) (long) jg;
1571   int r;
1572
1573   r = guestfs_lvm_remove_all (g);
1574   if (r == -1) {
1575     throw_exception (env, guestfs_last_error (g));
1576     return ;
1577   }
1578 }
1579
1580 JNIEXPORT jstring JNICALL
1581 Java_com_redhat_et_libguestfs_GuestFS__1file
1582   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1583 {
1584   guestfs_h *g = (guestfs_h *) (long) jg;
1585   jstring jr;
1586   char *r;
1587   const char *path;
1588
1589   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1590   r = guestfs_file (g, path);
1591   (*env)->ReleaseStringUTFChars (env, jpath, path);
1592   if (r == NULL) {
1593     throw_exception (env, guestfs_last_error (g));
1594     return NULL;
1595   }
1596   jr = (*env)->NewStringUTF (env, r);
1597   free (r);
1598   return jr;
1599 }
1600
1601 JNIEXPORT jstring JNICALL
1602 Java_com_redhat_et_libguestfs_GuestFS__1command
1603   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
1604 {
1605   guestfs_h *g = (guestfs_h *) (long) jg;
1606   jstring jr;
1607   char *r;
1608   int arguments_len;
1609   const char **arguments;
1610   int i;
1611
1612   arguments_len = (*env)->GetArrayLength (env, jarguments);
1613   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
1614   for (i = 0; i < arguments_len; ++i) {
1615     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1616     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
1617   }
1618   arguments[arguments_len] = NULL;
1619   r = guestfs_command (g, arguments);
1620   for (i = 0; i < arguments_len; ++i) {
1621     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1622     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
1623   }
1624   free (arguments);
1625   if (r == NULL) {
1626     throw_exception (env, guestfs_last_error (g));
1627     return NULL;
1628   }
1629   jr = (*env)->NewStringUTF (env, r);
1630   free (r);
1631   return jr;
1632 }
1633
1634 JNIEXPORT jobjectArray JNICALL
1635 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
1636   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
1637 {
1638   guestfs_h *g = (guestfs_h *) (long) jg;
1639   jobjectArray jr;
1640   int r_len;
1641   jclass cl;
1642   jstring jstr;
1643   char **r;
1644   int arguments_len;
1645   const char **arguments;
1646   int i;
1647
1648   arguments_len = (*env)->GetArrayLength (env, jarguments);
1649   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
1650   for (i = 0; i < arguments_len; ++i) {
1651     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1652     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
1653   }
1654   arguments[arguments_len] = NULL;
1655   r = guestfs_command_lines (g, arguments);
1656   for (i = 0; i < arguments_len; ++i) {
1657     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1658     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
1659   }
1660   free (arguments);
1661   if (r == NULL) {
1662     throw_exception (env, guestfs_last_error (g));
1663     return NULL;
1664   }
1665   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1666   cl = (*env)->FindClass (env, "java/lang/String");
1667   jstr = (*env)->NewStringUTF (env, "");
1668   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1669   for (i = 0; i < r_len; ++i) {
1670     jstr = (*env)->NewStringUTF (env, r[i]);
1671     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1672     free (r[i]);
1673   }
1674   free (r);
1675   return jr;
1676 }
1677
1678 JNIEXPORT jobject JNICALL
1679 Java_com_redhat_et_libguestfs_GuestFS__1stat
1680   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1681 {
1682   guestfs_h *g = (guestfs_h *) (long) jg;
1683   jobject jr;
1684   jclass cl;
1685   jfieldID fl;
1686   struct guestfs_stat *r;
1687   const char *path;
1688
1689   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1690   r = guestfs_stat (g, path);
1691   (*env)->ReleaseStringUTFChars (env, jpath, path);
1692   if (r == NULL) {
1693     throw_exception (env, guestfs_last_error (g));
1694     return NULL;
1695   }
1696   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
1697   jr = (*env)->AllocObject (env, cl);
1698   fl = (*env)->GetFieldID (env, cl, "dev", "J");
1699   (*env)->SetLongField (env, jr, fl, r->dev);
1700   fl = (*env)->GetFieldID (env, cl, "ino", "J");
1701   (*env)->SetLongField (env, jr, fl, r->ino);
1702   fl = (*env)->GetFieldID (env, cl, "mode", "J");
1703   (*env)->SetLongField (env, jr, fl, r->mode);
1704   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
1705   (*env)->SetLongField (env, jr, fl, r->nlink);
1706   fl = (*env)->GetFieldID (env, cl, "uid", "J");
1707   (*env)->SetLongField (env, jr, fl, r->uid);
1708   fl = (*env)->GetFieldID (env, cl, "gid", "J");
1709   (*env)->SetLongField (env, jr, fl, r->gid);
1710   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
1711   (*env)->SetLongField (env, jr, fl, r->rdev);
1712   fl = (*env)->GetFieldID (env, cl, "size", "J");
1713   (*env)->SetLongField (env, jr, fl, r->size);
1714   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
1715   (*env)->SetLongField (env, jr, fl, r->blksize);
1716   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1717   (*env)->SetLongField (env, jr, fl, r->blocks);
1718   fl = (*env)->GetFieldID (env, cl, "atime", "J");
1719   (*env)->SetLongField (env, jr, fl, r->atime);
1720   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
1721   (*env)->SetLongField (env, jr, fl, r->mtime);
1722   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
1723   (*env)->SetLongField (env, jr, fl, r->ctime);
1724   free (r);
1725   return jr;
1726 }
1727
1728 JNIEXPORT jobject JNICALL
1729 Java_com_redhat_et_libguestfs_GuestFS__1lstat
1730   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1731 {
1732   guestfs_h *g = (guestfs_h *) (long) jg;
1733   jobject jr;
1734   jclass cl;
1735   jfieldID fl;
1736   struct guestfs_stat *r;
1737   const char *path;
1738
1739   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1740   r = guestfs_lstat (g, path);
1741   (*env)->ReleaseStringUTFChars (env, jpath, path);
1742   if (r == NULL) {
1743     throw_exception (env, guestfs_last_error (g));
1744     return NULL;
1745   }
1746   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
1747   jr = (*env)->AllocObject (env, cl);
1748   fl = (*env)->GetFieldID (env, cl, "dev", "J");
1749   (*env)->SetLongField (env, jr, fl, r->dev);
1750   fl = (*env)->GetFieldID (env, cl, "ino", "J");
1751   (*env)->SetLongField (env, jr, fl, r->ino);
1752   fl = (*env)->GetFieldID (env, cl, "mode", "J");
1753   (*env)->SetLongField (env, jr, fl, r->mode);
1754   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
1755   (*env)->SetLongField (env, jr, fl, r->nlink);
1756   fl = (*env)->GetFieldID (env, cl, "uid", "J");
1757   (*env)->SetLongField (env, jr, fl, r->uid);
1758   fl = (*env)->GetFieldID (env, cl, "gid", "J");
1759   (*env)->SetLongField (env, jr, fl, r->gid);
1760   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
1761   (*env)->SetLongField (env, jr, fl, r->rdev);
1762   fl = (*env)->GetFieldID (env, cl, "size", "J");
1763   (*env)->SetLongField (env, jr, fl, r->size);
1764   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
1765   (*env)->SetLongField (env, jr, fl, r->blksize);
1766   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1767   (*env)->SetLongField (env, jr, fl, r->blocks);
1768   fl = (*env)->GetFieldID (env, cl, "atime", "J");
1769   (*env)->SetLongField (env, jr, fl, r->atime);
1770   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
1771   (*env)->SetLongField (env, jr, fl, r->mtime);
1772   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
1773   (*env)->SetLongField (env, jr, fl, r->ctime);
1774   free (r);
1775   return jr;
1776 }
1777
1778 JNIEXPORT jobject JNICALL
1779 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
1780   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1781 {
1782   guestfs_h *g = (guestfs_h *) (long) jg;
1783   jobject jr;
1784   jclass cl;
1785   jfieldID fl;
1786   struct guestfs_statvfs *r;
1787   const char *path;
1788
1789   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1790   r = guestfs_statvfs (g, path);
1791   (*env)->ReleaseStringUTFChars (env, jpath, path);
1792   if (r == NULL) {
1793     throw_exception (env, guestfs_last_error (g));
1794     return NULL;
1795   }
1796   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
1797   jr = (*env)->AllocObject (env, cl);
1798   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
1799   (*env)->SetLongField (env, jr, fl, r->bsize);
1800   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
1801   (*env)->SetLongField (env, jr, fl, r->frsize);
1802   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1803   (*env)->SetLongField (env, jr, fl, r->blocks);
1804   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
1805   (*env)->SetLongField (env, jr, fl, r->bfree);
1806   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
1807   (*env)->SetLongField (env, jr, fl, r->bavail);
1808   fl = (*env)->GetFieldID (env, cl, "files", "J");
1809   (*env)->SetLongField (env, jr, fl, r->files);
1810   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
1811   (*env)->SetLongField (env, jr, fl, r->ffree);
1812   fl = (*env)->GetFieldID (env, cl, "favail", "J");
1813   (*env)->SetLongField (env, jr, fl, r->favail);
1814   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
1815   (*env)->SetLongField (env, jr, fl, r->fsid);
1816   fl = (*env)->GetFieldID (env, cl, "flag", "J");
1817   (*env)->SetLongField (env, jr, fl, r->flag);
1818   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
1819   (*env)->SetLongField (env, jr, fl, r->namemax);
1820   free (r);
1821   return jr;
1822 }
1823
1824 JNIEXPORT jobject JNICALL
1825 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
1826   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1827 {
1828   guestfs_h *g = (guestfs_h *) (long) jg;
1829   char **r;
1830   const char *device;
1831
1832   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1833   r = guestfs_tune2fs_l (g, device);
1834   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1835   if (r == NULL) {
1836     throw_exception (env, guestfs_last_error (g));
1837     return NULL;
1838   }
1839   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1840   return NULL;
1841 }
1842
1843 JNIEXPORT void JNICALL
1844 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
1845   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1846 {
1847   guestfs_h *g = (guestfs_h *) (long) jg;
1848   int r;
1849   const char *device;
1850
1851   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1852   r = guestfs_blockdev_setro (g, device);
1853   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1854   if (r == -1) {
1855     throw_exception (env, guestfs_last_error (g));
1856     return ;
1857   }
1858 }
1859
1860 JNIEXPORT void JNICALL
1861 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
1862   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1863 {
1864   guestfs_h *g = (guestfs_h *) (long) jg;
1865   int r;
1866   const char *device;
1867
1868   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1869   r = guestfs_blockdev_setrw (g, device);
1870   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1871   if (r == -1) {
1872     throw_exception (env, guestfs_last_error (g));
1873     return ;
1874   }
1875 }
1876
1877 JNIEXPORT jboolean JNICALL
1878 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
1879   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1880 {
1881   guestfs_h *g = (guestfs_h *) (long) jg;
1882   int r;
1883   const char *device;
1884
1885   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1886   r = guestfs_blockdev_getro (g, device);
1887   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1888   if (r == -1) {
1889     throw_exception (env, guestfs_last_error (g));
1890     return 0;
1891   }
1892   return (jboolean) r;
1893 }
1894
1895 JNIEXPORT jint JNICALL
1896 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
1897   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1898 {
1899   guestfs_h *g = (guestfs_h *) (long) jg;
1900   int r;
1901   const char *device;
1902
1903   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1904   r = guestfs_blockdev_getss (g, device);
1905   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1906   if (r == -1) {
1907     throw_exception (env, guestfs_last_error (g));
1908     return 0;
1909   }
1910   return (jint) r;
1911 }
1912
1913 JNIEXPORT jint JNICALL
1914 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
1915   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1916 {
1917   guestfs_h *g = (guestfs_h *) (long) jg;
1918   int r;
1919   const char *device;
1920
1921   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1922   r = guestfs_blockdev_getbsz (g, device);
1923   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1924   if (r == -1) {
1925     throw_exception (env, guestfs_last_error (g));
1926     return 0;
1927   }
1928   return (jint) r;
1929 }
1930
1931 JNIEXPORT void JNICALL
1932 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
1933   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
1934 {
1935   guestfs_h *g = (guestfs_h *) (long) jg;
1936   int r;
1937   const char *device;
1938   int blocksize;
1939
1940   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1941   blocksize = jblocksize;
1942   r = guestfs_blockdev_setbsz (g, device, blocksize);
1943   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1944   if (r == -1) {
1945     throw_exception (env, guestfs_last_error (g));
1946     return ;
1947   }
1948 }
1949
1950 JNIEXPORT jlong JNICALL
1951 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
1952   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1953 {
1954   guestfs_h *g = (guestfs_h *) (long) jg;
1955   int64_t r;
1956   const char *device;
1957
1958   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1959   r = guestfs_blockdev_getsz (g, device);
1960   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1961   if (r == -1) {
1962     throw_exception (env, guestfs_last_error (g));
1963     return 0;
1964   }
1965   return (jlong) r;
1966 }
1967
1968 JNIEXPORT jlong JNICALL
1969 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
1970   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1971 {
1972   guestfs_h *g = (guestfs_h *) (long) jg;
1973   int64_t r;
1974   const char *device;
1975
1976   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1977   r = guestfs_blockdev_getsize64 (g, device);
1978   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1979   if (r == -1) {
1980     throw_exception (env, guestfs_last_error (g));
1981     return 0;
1982   }
1983   return (jlong) r;
1984 }
1985
1986 JNIEXPORT void JNICALL
1987 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
1988   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1989 {
1990   guestfs_h *g = (guestfs_h *) (long) jg;
1991   int r;
1992   const char *device;
1993
1994   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1995   r = guestfs_blockdev_flushbufs (g, device);
1996   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1997   if (r == -1) {
1998     throw_exception (env, guestfs_last_error (g));
1999     return ;
2000   }
2001 }
2002
2003 JNIEXPORT void JNICALL
2004 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
2005   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2006 {
2007   guestfs_h *g = (guestfs_h *) (long) jg;
2008   int r;
2009   const char *device;
2010
2011   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2012   r = guestfs_blockdev_rereadpt (g, device);
2013   (*env)->ReleaseStringUTFChars (env, jdevice, device);
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__1upload
2022   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
2023 {
2024   guestfs_h *g = (guestfs_h *) (long) jg;
2025   int r;
2026   const char *filename;
2027   const char *remotefilename;
2028
2029   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
2030   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
2031   r = guestfs_upload (g, filename, remotefilename);
2032   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
2033   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
2034   if (r == -1) {
2035     throw_exception (env, guestfs_last_error (g));
2036     return ;
2037   }
2038 }
2039
2040 JNIEXPORT void JNICALL
2041 Java_com_redhat_et_libguestfs_GuestFS__1download
2042   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
2043 {
2044   guestfs_h *g = (guestfs_h *) (long) jg;
2045   int r;
2046   const char *remotefilename;
2047   const char *filename;
2048
2049   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
2050   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
2051   r = guestfs_download (g, remotefilename, filename);
2052   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
2053   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
2054   if (r == -1) {
2055     throw_exception (env, guestfs_last_error (g));
2056     return ;
2057   }
2058 }
2059
2060 JNIEXPORT jstring JNICALL
2061 Java_com_redhat_et_libguestfs_GuestFS__1checksum
2062   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
2063 {
2064   guestfs_h *g = (guestfs_h *) (long) jg;
2065   jstring jr;
2066   char *r;
2067   const char *csumtype;
2068   const char *path;
2069
2070   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
2071   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2072   r = guestfs_checksum (g, csumtype, path);
2073   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
2074   (*env)->ReleaseStringUTFChars (env, jpath, path);
2075   if (r == NULL) {
2076     throw_exception (env, guestfs_last_error (g));
2077     return NULL;
2078   }
2079   jr = (*env)->NewStringUTF (env, r);
2080   free (r);
2081   return jr;
2082 }
2083
2084 JNIEXPORT void JNICALL
2085 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
2086   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
2087 {
2088   guestfs_h *g = (guestfs_h *) (long) jg;
2089   int r;
2090   const char *tarfile;
2091   const char *directory;
2092
2093   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
2094   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2095   r = guestfs_tar_in (g, tarfile, directory);
2096   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
2097   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2098   if (r == -1) {
2099     throw_exception (env, guestfs_last_error (g));
2100     return ;
2101   }
2102 }
2103
2104 JNIEXPORT void JNICALL
2105 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
2106   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
2107 {
2108   guestfs_h *g = (guestfs_h *) (long) jg;
2109   int r;
2110   const char *directory;
2111   const char *tarfile;
2112
2113   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2114   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
2115   r = guestfs_tar_out (g, directory, tarfile);
2116   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2117   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
2118   if (r == -1) {
2119     throw_exception (env, guestfs_last_error (g));
2120     return ;
2121   }
2122 }
2123
2124 JNIEXPORT void JNICALL
2125 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
2126   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
2127 {
2128   guestfs_h *g = (guestfs_h *) (long) jg;
2129   int r;
2130   const char *tarball;
2131   const char *directory;
2132
2133   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
2134   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2135   r = guestfs_tgz_in (g, tarball, directory);
2136   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
2137   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2138   if (r == -1) {
2139     throw_exception (env, guestfs_last_error (g));
2140     return ;
2141   }
2142 }
2143
2144 JNIEXPORT void JNICALL
2145 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
2146   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
2147 {
2148   guestfs_h *g = (guestfs_h *) (long) jg;
2149   int r;
2150   const char *directory;
2151   const char *tarball;
2152
2153   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2154   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
2155   r = guestfs_tgz_out (g, directory, tarball);
2156   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2157   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
2158   if (r == -1) {
2159     throw_exception (env, guestfs_last_error (g));
2160     return ;
2161   }
2162 }
2163
2164 JNIEXPORT void JNICALL
2165 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
2166   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
2167 {
2168   guestfs_h *g = (guestfs_h *) (long) jg;
2169   int r;
2170   const char *device;
2171   const char *mountpoint;
2172
2173   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2174   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
2175   r = guestfs_mount_ro (g, device, mountpoint);
2176   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2177   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
2178   if (r == -1) {
2179     throw_exception (env, guestfs_last_error (g));
2180     return ;
2181   }
2182 }
2183
2184 JNIEXPORT void JNICALL
2185 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
2186   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
2187 {
2188   guestfs_h *g = (guestfs_h *) (long) jg;
2189   int r;
2190   const char *options;
2191   const char *device;
2192   const char *mountpoint;
2193
2194   options = (*env)->GetStringUTFChars (env, joptions, NULL);
2195   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2196   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
2197   r = guestfs_mount_options (g, options, device, mountpoint);
2198   (*env)->ReleaseStringUTFChars (env, joptions, options);
2199   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2200   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
2201   if (r == -1) {
2202     throw_exception (env, guestfs_last_error (g));
2203     return ;
2204   }
2205 }
2206
2207 JNIEXPORT void JNICALL
2208 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
2209   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
2210 {
2211   guestfs_h *g = (guestfs_h *) (long) jg;
2212   int r;
2213   const char *options;
2214   const char *vfstype;
2215   const char *device;
2216   const char *mountpoint;
2217
2218   options = (*env)->GetStringUTFChars (env, joptions, NULL);
2219   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
2220   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2221   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
2222   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2223   (*env)->ReleaseStringUTFChars (env, joptions, options);
2224   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
2225   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2226   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
2227   if (r == -1) {
2228     throw_exception (env, guestfs_last_error (g));
2229     return ;
2230   }
2231 }
2232
2233 JNIEXPORT jstring JNICALL
2234 Java_com_redhat_et_libguestfs_GuestFS__1debug
2235   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
2236 {
2237   guestfs_h *g = (guestfs_h *) (long) jg;
2238   jstring jr;
2239   char *r;
2240   const char *subcmd;
2241   int extraargs_len;
2242   const char **extraargs;
2243   int i;
2244
2245   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
2246   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
2247   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
2248   for (i = 0; i < extraargs_len; ++i) {
2249     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
2250     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
2251   }
2252   extraargs[extraargs_len] = NULL;
2253   r = guestfs_debug (g, subcmd, extraargs);
2254   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
2255   for (i = 0; i < extraargs_len; ++i) {
2256     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
2257     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
2258   }
2259   free (extraargs);
2260   if (r == NULL) {
2261     throw_exception (env, guestfs_last_error (g));
2262     return NULL;
2263   }
2264   jr = (*env)->NewStringUTF (env, r);
2265   free (r);
2266   return jr;
2267 }
2268
2269 JNIEXPORT void JNICALL
2270 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
2271   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2272 {
2273   guestfs_h *g = (guestfs_h *) (long) jg;
2274   int r;
2275   const char *device;
2276
2277   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2278   r = guestfs_lvremove (g, device);
2279   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2280   if (r == -1) {
2281     throw_exception (env, guestfs_last_error (g));
2282     return ;
2283   }
2284 }
2285
2286 JNIEXPORT void JNICALL
2287 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
2288   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
2289 {
2290   guestfs_h *g = (guestfs_h *) (long) jg;
2291   int r;
2292   const char *vgname;
2293
2294   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
2295   r = guestfs_vgremove (g, vgname);
2296   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
2297   if (r == -1) {
2298     throw_exception (env, guestfs_last_error (g));
2299     return ;
2300   }
2301 }
2302
2303 JNIEXPORT void JNICALL
2304 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
2305   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2306 {
2307   guestfs_h *g = (guestfs_h *) (long) jg;
2308   int r;
2309   const char *device;
2310
2311   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2312   r = guestfs_pvremove (g, device);
2313   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2314   if (r == -1) {
2315     throw_exception (env, guestfs_last_error (g));
2316     return ;
2317   }
2318 }
2319
2320 JNIEXPORT void JNICALL
2321 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
2322   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
2323 {
2324   guestfs_h *g = (guestfs_h *) (long) jg;
2325   int r;
2326   const char *device;
2327   const char *label;
2328
2329   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2330   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2331   r = guestfs_set_e2label (g, device, label);
2332   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2333   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2334   if (r == -1) {
2335     throw_exception (env, guestfs_last_error (g));
2336     return ;
2337   }
2338 }
2339
2340 JNIEXPORT jstring JNICALL
2341 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
2342   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2343 {
2344   guestfs_h *g = (guestfs_h *) (long) jg;
2345   jstring jr;
2346   char *r;
2347   const char *device;
2348
2349   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2350   r = guestfs_get_e2label (g, device);
2351   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2352   if (r == NULL) {
2353     throw_exception (env, guestfs_last_error (g));
2354     return NULL;
2355   }
2356   jr = (*env)->NewStringUTF (env, r);
2357   free (r);
2358   return jr;
2359 }
2360
2361 JNIEXPORT void JNICALL
2362 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
2363   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
2364 {
2365   guestfs_h *g = (guestfs_h *) (long) jg;
2366   int r;
2367   const char *device;
2368   const char *uuid;
2369
2370   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2371   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
2372   r = guestfs_set_e2uuid (g, device, uuid);
2373   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2374   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
2375   if (r == -1) {
2376     throw_exception (env, guestfs_last_error (g));
2377     return ;
2378   }
2379 }
2380
2381 JNIEXPORT jstring JNICALL
2382 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
2383   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2384 {
2385   guestfs_h *g = (guestfs_h *) (long) jg;
2386   jstring jr;
2387   char *r;
2388   const char *device;
2389
2390   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2391   r = guestfs_get_e2uuid (g, device);
2392   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2393   if (r == NULL) {
2394     throw_exception (env, guestfs_last_error (g));
2395     return NULL;
2396   }
2397   jr = (*env)->NewStringUTF (env, r);
2398   free (r);
2399   return jr;
2400 }
2401
2402 JNIEXPORT jint JNICALL
2403 Java_com_redhat_et_libguestfs_GuestFS__1fsck
2404   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2405 {
2406   guestfs_h *g = (guestfs_h *) (long) jg;
2407   int r;
2408   const char *fstype;
2409   const char *device;
2410
2411   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2412   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2413   r = guestfs_fsck (g, fstype, device);
2414   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2415   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2416   if (r == -1) {
2417     throw_exception (env, guestfs_last_error (g));
2418     return 0;
2419   }
2420   return (jint) r;
2421 }
2422
2423 JNIEXPORT void JNICALL
2424 Java_com_redhat_et_libguestfs_GuestFS__1zero
2425   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2426 {
2427   guestfs_h *g = (guestfs_h *) (long) jg;
2428   int r;
2429   const char *device;
2430
2431   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2432   r = guestfs_zero (g, device);
2433   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2434   if (r == -1) {
2435     throw_exception (env, guestfs_last_error (g));
2436     return ;
2437   }
2438 }
2439
2440 JNIEXPORT void JNICALL
2441 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
2442   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
2443 {
2444   guestfs_h *g = (guestfs_h *) (long) jg;
2445   int r;
2446   const char *root;
2447   const char *device;
2448
2449   root = (*env)->GetStringUTFChars (env, jroot, NULL);
2450   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2451   r = guestfs_grub_install (g, root, device);
2452   (*env)->ReleaseStringUTFChars (env, jroot, root);
2453   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2454   if (r == -1) {
2455     throw_exception (env, guestfs_last_error (g));
2456     return ;
2457   }
2458 }
2459