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__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__1end_1busy
 391   (JNIEnv *env, jobject obj, jlong jg)
 392 {
 393   guestfs_h *g = (guestfs_h *) (long) jg;
 394   int r;
 395
 396   r = guestfs_end_busy (g);
 397   if (r == -1) {
 398     throw_exception (env, guestfs_last_error (g));
 399     return ;
 400   }
 401 }
 402
 403 JNIEXPORT void JNICALL
 404 Java_com_redhat_et_libguestfs_GuestFS__1mount
 405   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
 406 {
 407   guestfs_h *g = (guestfs_h *) (long) jg;
 408   int r;
 409   const char *device;
 410   const char *mountpoint;
 411
 412   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
 413   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
 414   r = guestfs_mount (g, device, mountpoint);
 415   (*env)->ReleaseStringUTFChars (env, jdevice, device);
 416   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
 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__1sync
 425   (JNIEnv *env, jobject obj, jlong jg)
 426 {
 427   guestfs_h *g = (guestfs_h *) (long) jg;
 428   int r;
 429
 430   r = guestfs_sync (g);
 431   if (r == -1) {
 432     throw_exception (env, guestfs_last_error (g));
 433     return ;
 434   }
 435 }
 436
 437 JNIEXPORT void JNICALL
 438 Java_com_redhat_et_libguestfs_GuestFS__1touch
 439   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 440 {
 441   guestfs_h *g = (guestfs_h *) (long) jg;
 442   int r;
 443   const char *path;
 444
 445   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 446   r = guestfs_touch (g, path);
 447   (*env)->ReleaseStringUTFChars (env, jpath, path);
 448   if (r == -1) {
 449     throw_exception (env, guestfs_last_error (g));
 450     return ;
 451   }
 452 }
 453
 454 JNIEXPORT jstring JNICALL
 455 Java_com_redhat_et_libguestfs_GuestFS__1cat
 456   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 457 {
 458   guestfs_h *g = (guestfs_h *) (long) jg;
 459   jstring jr;
 460   char *r;
 461   const char *path;
 462
 463   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 464   r = guestfs_cat (g, path);
 465   (*env)->ReleaseStringUTFChars (env, jpath, path);
 466   if (r == NULL) {
 467     throw_exception (env, guestfs_last_error (g));
 468     return NULL;
 469   }
 470   jr = (*env)->NewStringUTF (env, r);
 471   free (r);
 472   return jr;
 473 }
 474
 475 JNIEXPORT jstring JNICALL
 476 Java_com_redhat_et_libguestfs_GuestFS__1ll
 477   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
 478 {
 479   guestfs_h *g = (guestfs_h *) (long) jg;
 480   jstring jr;
 481   char *r;
 482   const char *directory;
 483
 484   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
 485   r = guestfs_ll (g, directory);
 486   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
 487   if (r == NULL) {
 488     throw_exception (env, guestfs_last_error (g));
 489     return NULL;
 490   }
 491   jr = (*env)->NewStringUTF (env, r);
 492   free (r);
 493   return jr;
 494 }
 495
 496 JNIEXPORT jobjectArray JNICALL
 497 Java_com_redhat_et_libguestfs_GuestFS__1ls
 498   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
 499 {
 500   guestfs_h *g = (guestfs_h *) (long) jg;
 501   jobjectArray jr;
 502   int r_len;
 503   jclass cl;
 504   jstring jstr;
 505   char **r;
 506   const char *directory;
 507   int i;
 508
 509   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
 510   r = guestfs_ls (g, directory);
 511   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
 512   if (r == NULL) {
 513     throw_exception (env, guestfs_last_error (g));
 514     return NULL;
 515   }
 516   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 517   cl = (*env)->FindClass (env, "java/lang/String");
 518   jstr = (*env)->NewStringUTF (env, "");
 519   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 520   for (i = 0; i < r_len; ++i) {
 521     jstr = (*env)->NewStringUTF (env, r[i]);
 522     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 523     free (r[i]);
 524   }
 525   free (r);
 526   return jr;
 527 }
 528
 529 JNIEXPORT jobjectArray JNICALL
 530 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
 531   (JNIEnv *env, jobject obj, jlong jg)
 532 {
 533   guestfs_h *g = (guestfs_h *) (long) jg;
 534   jobjectArray jr;
 535   int r_len;
 536   jclass cl;
 537   jstring jstr;
 538   char **r;
 539   int i;
 540
 541   r = guestfs_list_devices (g);
 542   if (r == NULL) {
 543     throw_exception (env, guestfs_last_error (g));
 544     return NULL;
 545   }
 546   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 547   cl = (*env)->FindClass (env, "java/lang/String");
 548   jstr = (*env)->NewStringUTF (env, "");
 549   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 550   for (i = 0; i < r_len; ++i) {
 551     jstr = (*env)->NewStringUTF (env, r[i]);
 552     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 553     free (r[i]);
 554   }
 555   free (r);
 556   return jr;
 557 }
 558
 559 JNIEXPORT jobjectArray JNICALL
 560 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
 561   (JNIEnv *env, jobject obj, jlong jg)
 562 {
 563   guestfs_h *g = (guestfs_h *) (long) jg;
 564   jobjectArray jr;
 565   int r_len;
 566   jclass cl;
 567   jstring jstr;
 568   char **r;
 569   int i;
 570
 571   r = guestfs_list_partitions (g);
 572   if (r == NULL) {
 573     throw_exception (env, guestfs_last_error (g));
 574     return NULL;
 575   }
 576   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 577   cl = (*env)->FindClass (env, "java/lang/String");
 578   jstr = (*env)->NewStringUTF (env, "");
 579   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 580   for (i = 0; i < r_len; ++i) {
 581     jstr = (*env)->NewStringUTF (env, r[i]);
 582     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 583     free (r[i]);
 584   }
 585   free (r);
 586   return jr;
 587 }
 588
 589 JNIEXPORT jobjectArray JNICALL
 590 Java_com_redhat_et_libguestfs_GuestFS__1pvs
 591   (JNIEnv *env, jobject obj, jlong jg)
 592 {
 593   guestfs_h *g = (guestfs_h *) (long) jg;
 594   jobjectArray jr;
 595   int r_len;
 596   jclass cl;
 597   jstring jstr;
 598   char **r;
 599   int i;
 600
 601   r = guestfs_pvs (g);
 602   if (r == NULL) {
 603     throw_exception (env, guestfs_last_error (g));
 604     return NULL;
 605   }
 606   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 607   cl = (*env)->FindClass (env, "java/lang/String");
 608   jstr = (*env)->NewStringUTF (env, "");
 609   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 610   for (i = 0; i < r_len; ++i) {
 611     jstr = (*env)->NewStringUTF (env, r[i]);
 612     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 613     free (r[i]);
 614   }
 615   free (r);
 616   return jr;
 617 }
 618
 619 JNIEXPORT jobjectArray JNICALL
 620 Java_com_redhat_et_libguestfs_GuestFS__1vgs
 621   (JNIEnv *env, jobject obj, jlong jg)
 622 {
 623   guestfs_h *g = (guestfs_h *) (long) jg;
 624   jobjectArray jr;
 625   int r_len;
 626   jclass cl;
 627   jstring jstr;
 628   char **r;
 629   int i;
 630
 631   r = guestfs_vgs (g);
 632   if (r == NULL) {
 633     throw_exception (env, guestfs_last_error (g));
 634     return NULL;
 635   }
 636   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 637   cl = (*env)->FindClass (env, "java/lang/String");
 638   jstr = (*env)->NewStringUTF (env, "");
 639   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 640   for (i = 0; i < r_len; ++i) {
 641     jstr = (*env)->NewStringUTF (env, r[i]);
 642     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 643     free (r[i]);
 644   }
 645   free (r);
 646   return jr;
 647 }
 648
 649 JNIEXPORT jobjectArray JNICALL
 650 Java_com_redhat_et_libguestfs_GuestFS__1lvs
 651   (JNIEnv *env, jobject obj, jlong jg)
 652 {
 653   guestfs_h *g = (guestfs_h *) (long) jg;
 654   jobjectArray jr;
 655   int r_len;
 656   jclass cl;
 657   jstring jstr;
 658   char **r;
 659   int i;
 660
 661   r = guestfs_lvs (g);
 662   if (r == NULL) {
 663     throw_exception (env, guestfs_last_error (g));
 664     return NULL;
 665   }
 666   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 667   cl = (*env)->FindClass (env, "java/lang/String");
 668   jstr = (*env)->NewStringUTF (env, "");
 669   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 670   for (i = 0; i < r_len; ++i) {
 671     jstr = (*env)->NewStringUTF (env, r[i]);
 672     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 673     free (r[i]);
 674   }
 675   free (r);
 676   return jr;
 677 }
 678
 679 JNIEXPORT jobjectArray JNICALL
 680 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
 681   (JNIEnv *env, jobject obj, jlong jg)
 682 {
 683   guestfs_h *g = (guestfs_h *) (long) jg;
 684   jobjectArray jr;
 685   jclass cl;
 686   jfieldID fl;
 687   jobject jfl;
 688   struct guestfs_lvm_pv_list *r;
 689   int i;
 690
 691   r = guestfs_pvs_full (g);
 692   if (r == NULL) {
 693     throw_exception (env, guestfs_last_error (g));
 694     return NULL;
 695   }
 696   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 697   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 698   for (i = 0; i < r->len; ++i) {
 699     jfl = (*env)->AllocObject (env, cl);
 700     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 701     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 702     {
 703       char s[33];
 704       memcpy (s, r->val[i].pv_uuid, 32);
 705       s[32] = 0;
 706       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 707       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 708     }
 709     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 710     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 711     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 712     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 713     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 714     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 715     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 716     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 717     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 718     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 719     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 720     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 721     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 722     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 723     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 724     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 725     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 726     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 727     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 728     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 729     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 730     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 731     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 732     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 733     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 734   }
 735   guestfs_free_lvm_pv_list (r);
 736   return jr;
 737 }
 738
 739 JNIEXPORT jobjectArray JNICALL
 740 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
 741   (JNIEnv *env, jobject obj, jlong jg)
 742 {
 743   guestfs_h *g = (guestfs_h *) (long) jg;
 744   jobjectArray jr;
 745   jclass cl;
 746   jfieldID fl;
 747   jobject jfl;
 748   struct guestfs_lvm_vg_list *r;
 749   int i;
 750
 751   r = guestfs_vgs_full (g);
 752   if (r == NULL) {
 753     throw_exception (env, guestfs_last_error (g));
 754     return NULL;
 755   }
 756   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 757   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 758   for (i = 0; i < r->len; ++i) {
 759     jfl = (*env)->AllocObject (env, cl);
 760     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 761     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 762     {
 763       char s[33];
 764       memcpy (s, r->val[i].vg_uuid, 32);
 765       s[32] = 0;
 766       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 767       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 768     }
 769     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 770     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 771     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 772     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 773     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 774     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 775     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 776     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 777     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 778     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 779     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 780     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 781     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 782     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 783     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 784     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 785     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 786     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 787     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 788     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 789     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 790     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 791     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 792     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 793     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 794     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 795     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 796     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 797     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 798     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 799     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 800     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 801     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 802     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 803     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 804   }
 805   guestfs_free_lvm_vg_list (r);
 806   return jr;
 807 }
 808
 809 JNIEXPORT jobjectArray JNICALL
 810 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
 811   (JNIEnv *env, jobject obj, jlong jg)
 812 {
 813   guestfs_h *g = (guestfs_h *) (long) jg;
 814   jobjectArray jr;
 815   jclass cl;
 816   jfieldID fl;
 817   jobject jfl;
 818   struct guestfs_lvm_lv_list *r;
 819   int i;
 820
 821   r = guestfs_lvs_full (g);
 822   if (r == NULL) {
 823     throw_exception (env, guestfs_last_error (g));
 824     return NULL;
 825   }
 826   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
 827   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 828   for (i = 0; i < r->len; ++i) {
 829     jfl = (*env)->AllocObject (env, cl);
 830     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 831     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 832     {
 833       char s[33];
 834       memcpy (s, r->val[i].lv_uuid, 32);
 835       s[32] = 0;
 836       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 837       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 838     }
 839     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 840     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 841     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 842     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 843     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 844     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 845     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 846     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 847     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 848     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 849     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 850     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 851     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 852     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 853     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 854     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 855     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 856     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 857     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 858     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 859     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 860     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 861     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 862     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 863     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 864     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 865     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 866     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 867     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 868   }
 869   guestfs_free_lvm_lv_list (r);
 870   return jr;
 871 }
 872
 873 JNIEXPORT jobjectArray JNICALL
 874 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
 875   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 876 {
 877   guestfs_h *g = (guestfs_h *) (long) jg;
 878   jobjectArray jr;
 879   int r_len;
 880   jclass cl;
 881   jstring jstr;
 882   char **r;
 883   const char *path;
 884   int i;
 885
 886   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 887   r = guestfs_read_lines (g, path);
 888   (*env)->ReleaseStringUTFChars (env, jpath, path);
 889   if (r == NULL) {
 890     throw_exception (env, guestfs_last_error (g));
 891     return NULL;
 892   }
 893   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 894   cl = (*env)->FindClass (env, "java/lang/String");
 895   jstr = (*env)->NewStringUTF (env, "");
 896   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 897   for (i = 0; i < r_len; ++i) {
 898     jstr = (*env)->NewStringUTF (env, r[i]);
 899     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 900     free (r[i]);
 901   }
 902   free (r);
 903   return jr;
 904 }
 905
 906 JNIEXPORT void JNICALL
 907 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
 908   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
 909 {
 910   guestfs_h *g = (guestfs_h *) (long) jg;
 911   int r;
 912   const char *root;
 913   int flags;
 914
 915   root = (*env)->GetStringUTFChars (env, jroot, NULL);
 916   flags = jflags;
 917   r = guestfs_aug_init (g, root, flags);
 918   (*env)->ReleaseStringUTFChars (env, jroot, root);
 919   if (r == -1) {
 920     throw_exception (env, guestfs_last_error (g));
 921     return ;
 922   }
 923 }
 924
 925 JNIEXPORT void JNICALL
 926 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
 927   (JNIEnv *env, jobject obj, jlong jg)
 928 {
 929   guestfs_h *g = (guestfs_h *) (long) jg;
 930   int r;
 931
 932   r = guestfs_aug_close (g);
 933   if (r == -1) {
 934     throw_exception (env, guestfs_last_error (g));
 935     return ;
 936   }
 937 }
 938
 939 JNIEXPORT jint JNICALL
 940 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
 941   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
 942 {
 943   guestfs_h *g = (guestfs_h *) (long) jg;
 944   int r;
 945   const char *name;
 946   const char *expr;
 947
 948   name = (*env)->GetStringUTFChars (env, jname, NULL);
 949   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
 950   r = guestfs_aug_defvar (g, name, expr);
 951   (*env)->ReleaseStringUTFChars (env, jname, name);
 952   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
 953   if (r == -1) {
 954     throw_exception (env, guestfs_last_error (g));
 955     return 0;
 956   }
 957   return (jint) r;
 958 }
 959
 960 JNIEXPORT jobject JNICALL
 961 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
 962   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
 963 {
 964   guestfs_h *g = (guestfs_h *) (long) jg;
 965   jobject jr;
 966   jclass cl;
 967   jfieldID fl;
 968   struct guestfs_int_bool *r;
 969   const char *name;
 970   const char *expr;
 971   const char *val;
 972
 973   name = (*env)->GetStringUTFChars (env, jname, NULL);
 974   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
 975   val = (*env)->GetStringUTFChars (env, jval, NULL);
 976   r = guestfs_aug_defnode (g, name, expr, val);
 977   (*env)->ReleaseStringUTFChars (env, jname, name);
 978   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
 979   (*env)->ReleaseStringUTFChars (env, jval, val);
 980   if (r == NULL) {
 981     throw_exception (env, guestfs_last_error (g));
 982     return NULL;
 983   }
 984   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 985   jr = (*env)->AllocObject (env, cl);
 986   fl = (*env)->GetFieldID (env, cl, "i", "I");
 987   (*env)->SetIntField (env, jr, fl, r->i);
 988   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 989   (*env)->SetBooleanField (env, jr, fl, r->b);
 990   guestfs_free_int_bool (r);
 991   return jr;
 992 }
 993
 994 JNIEXPORT jstring JNICALL
 995 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
 996   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 997 {
 998   guestfs_h *g = (guestfs_h *) (long) jg;
 999   jstring jr;
1000   char *r;
1001   const char *path;
1002
1003   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1004   r = guestfs_aug_get (g, path);
1005   (*env)->ReleaseStringUTFChars (env, jpath, path);
1006   if (r == NULL) {
1007     throw_exception (env, guestfs_last_error (g));
1008     return NULL;
1009   }
1010   jr = (*env)->NewStringUTF (env, r);
1011   free (r);
1012   return jr;
1013 }
1014
1015 JNIEXPORT void JNICALL
1016 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
1017   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
1018 {
1019   guestfs_h *g = (guestfs_h *) (long) jg;
1020   int r;
1021   const char *path;
1022   const char *val;
1023
1024   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1025   val = (*env)->GetStringUTFChars (env, jval, NULL);
1026   r = guestfs_aug_set (g, path, val);
1027   (*env)->ReleaseStringUTFChars (env, jpath, path);
1028   (*env)->ReleaseStringUTFChars (env, jval, val);
1029   if (r == -1) {
1030     throw_exception (env, guestfs_last_error (g));
1031     return ;
1032   }
1033 }
1034
1035 JNIEXPORT void JNICALL
1036 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
1037   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
1038 {
1039   guestfs_h *g = (guestfs_h *) (long) jg;
1040   int r;
1041   const char *path;
1042   const char *label;
1043   int before;
1044
1045   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1046   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
1047   before = jbefore;
1048   r = guestfs_aug_insert (g, path, label, before);
1049   (*env)->ReleaseStringUTFChars (env, jpath, path);
1050   (*env)->ReleaseStringUTFChars (env, jlabel, label);
1051   if (r == -1) {
1052     throw_exception (env, guestfs_last_error (g));
1053     return ;
1054   }
1055 }
1056
1057 JNIEXPORT jint JNICALL
1058 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
1059   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1060 {
1061   guestfs_h *g = (guestfs_h *) (long) jg;
1062   int r;
1063   const char *path;
1064
1065   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1066   r = guestfs_aug_rm (g, path);
1067   (*env)->ReleaseStringUTFChars (env, jpath, path);
1068   if (r == -1) {
1069     throw_exception (env, guestfs_last_error (g));
1070     return 0;
1071   }
1072   return (jint) r;
1073 }
1074
1075 JNIEXPORT void JNICALL
1076 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
1077   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
1078 {
1079   guestfs_h *g = (guestfs_h *) (long) jg;
1080   int r;
1081   const char *src;
1082   const char *dest;
1083
1084   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
1085   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
1086   r = guestfs_aug_mv (g, src, dest);
1087   (*env)->ReleaseStringUTFChars (env, jsrc, src);
1088   (*env)->ReleaseStringUTFChars (env, jdest, dest);
1089   if (r == -1) {
1090     throw_exception (env, guestfs_last_error (g));
1091     return ;
1092   }
1093 }
1094
1095 JNIEXPORT jobjectArray JNICALL
1096 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
1097   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1098 {
1099   guestfs_h *g = (guestfs_h *) (long) jg;
1100   jobjectArray jr;
1101   int r_len;
1102   jclass cl;
1103   jstring jstr;
1104   char **r;
1105   const char *path;
1106   int i;
1107
1108   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1109   r = guestfs_aug_match (g, path);
1110   (*env)->ReleaseStringUTFChars (env, jpath, path);
1111   if (r == NULL) {
1112     throw_exception (env, guestfs_last_error (g));
1113     return NULL;
1114   }
1115   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1116   cl = (*env)->FindClass (env, "java/lang/String");
1117   jstr = (*env)->NewStringUTF (env, "");
1118   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1119   for (i = 0; i < r_len; ++i) {
1120     jstr = (*env)->NewStringUTF (env, r[i]);
1121     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1122     free (r[i]);
1123   }
1124   free (r);
1125   return jr;
1126 }
1127
1128 JNIEXPORT void JNICALL
1129 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
1130   (JNIEnv *env, jobject obj, jlong jg)
1131 {
1132   guestfs_h *g = (guestfs_h *) (long) jg;
1133   int r;
1134
1135   r = guestfs_aug_save (g);
1136   if (r == -1) {
1137     throw_exception (env, guestfs_last_error (g));
1138     return ;
1139   }
1140 }
1141
1142 JNIEXPORT void JNICALL
1143 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
1144   (JNIEnv *env, jobject obj, jlong jg)
1145 {
1146   guestfs_h *g = (guestfs_h *) (long) jg;
1147   int r;
1148
1149   r = guestfs_aug_load (g);
1150   if (r == -1) {
1151     throw_exception (env, guestfs_last_error (g));
1152     return ;
1153   }
1154 }
1155
1156 JNIEXPORT jobjectArray JNICALL
1157 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
1158   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1159 {
1160   guestfs_h *g = (guestfs_h *) (long) jg;
1161   jobjectArray jr;
1162   int r_len;
1163   jclass cl;
1164   jstring jstr;
1165   char **r;
1166   const char *path;
1167   int i;
1168
1169   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1170   r = guestfs_aug_ls (g, path);
1171   (*env)->ReleaseStringUTFChars (env, jpath, path);
1172   if (r == NULL) {
1173     throw_exception (env, guestfs_last_error (g));
1174     return NULL;
1175   }
1176   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1177   cl = (*env)->FindClass (env, "java/lang/String");
1178   jstr = (*env)->NewStringUTF (env, "");
1179   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1180   for (i = 0; i < r_len; ++i) {
1181     jstr = (*env)->NewStringUTF (env, r[i]);
1182     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1183     free (r[i]);
1184   }
1185   free (r);
1186   return jr;
1187 }
1188
1189 JNIEXPORT void JNICALL
1190 Java_com_redhat_et_libguestfs_GuestFS__1rm
1191   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1192 {
1193   guestfs_h *g = (guestfs_h *) (long) jg;
1194   int r;
1195   const char *path;
1196
1197   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1198   r = guestfs_rm (g, path);
1199   (*env)->ReleaseStringUTFChars (env, jpath, path);
1200   if (r == -1) {
1201     throw_exception (env, guestfs_last_error (g));
1202     return ;
1203   }
1204 }
1205
1206 JNIEXPORT void JNICALL
1207 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
1208   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1209 {
1210   guestfs_h *g = (guestfs_h *) (long) jg;
1211   int r;
1212   const char *path;
1213
1214   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1215   r = guestfs_rmdir (g, path);
1216   (*env)->ReleaseStringUTFChars (env, jpath, path);
1217   if (r == -1) {
1218     throw_exception (env, guestfs_last_error (g));
1219     return ;
1220   }
1221 }
1222
1223 JNIEXPORT void JNICALL
1224 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
1225   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1226 {
1227   guestfs_h *g = (guestfs_h *) (long) jg;
1228   int r;
1229   const char *path;
1230
1231   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1232   r = guestfs_rm_rf (g, path);
1233   (*env)->ReleaseStringUTFChars (env, jpath, path);
1234   if (r == -1) {
1235     throw_exception (env, guestfs_last_error (g));
1236     return ;
1237   }
1238 }
1239
1240 JNIEXPORT void JNICALL
1241 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
1242   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1243 {
1244   guestfs_h *g = (guestfs_h *) (long) jg;
1245   int r;
1246   const char *path;
1247
1248   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1249   r = guestfs_mkdir (g, path);
1250   (*env)->ReleaseStringUTFChars (env, jpath, path);
1251   if (r == -1) {
1252     throw_exception (env, guestfs_last_error (g));
1253     return ;
1254   }
1255 }
1256
1257 JNIEXPORT void JNICALL
1258 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
1259   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1260 {
1261   guestfs_h *g = (guestfs_h *) (long) jg;
1262   int r;
1263   const char *path;
1264
1265   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1266   r = guestfs_mkdir_p (g, path);
1267   (*env)->ReleaseStringUTFChars (env, jpath, path);
1268   if (r == -1) {
1269     throw_exception (env, guestfs_last_error (g));
1270     return ;
1271   }
1272 }
1273
1274 JNIEXPORT void JNICALL
1275 Java_com_redhat_et_libguestfs_GuestFS__1chmod
1276   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
1277 {
1278   guestfs_h *g = (guestfs_h *) (long) jg;
1279   int r;
1280   int mode;
1281   const char *path;
1282
1283   mode = jmode;
1284   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1285   r = guestfs_chmod (g, mode, path);
1286   (*env)->ReleaseStringUTFChars (env, jpath, path);
1287   if (r == -1) {
1288     throw_exception (env, guestfs_last_error (g));
1289     return ;
1290   }
1291 }
1292
1293 JNIEXPORT void JNICALL
1294 Java_com_redhat_et_libguestfs_GuestFS__1chown
1295   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
1296 {
1297   guestfs_h *g = (guestfs_h *) (long) jg;
1298   int r;
1299   int owner;
1300   int group;
1301   const char *path;
1302
1303   owner = jowner;
1304   group = jgroup;
1305   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1306   r = guestfs_chown (g, owner, group, path);
1307   (*env)->ReleaseStringUTFChars (env, jpath, path);
1308   if (r == -1) {
1309     throw_exception (env, guestfs_last_error (g));
1310     return ;
1311   }
1312 }
1313
1314 JNIEXPORT jboolean JNICALL
1315 Java_com_redhat_et_libguestfs_GuestFS__1exists
1316   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1317 {
1318   guestfs_h *g = (guestfs_h *) (long) jg;
1319   int r;
1320   const char *path;
1321
1322   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1323   r = guestfs_exists (g, path);
1324   (*env)->ReleaseStringUTFChars (env, jpath, path);
1325   if (r == -1) {
1326     throw_exception (env, guestfs_last_error (g));
1327     return 0;
1328   }
1329   return (jboolean) r;
1330 }
1331
1332 JNIEXPORT jboolean JNICALL
1333 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
1334   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1335 {
1336   guestfs_h *g = (guestfs_h *) (long) jg;
1337   int r;
1338   const char *path;
1339
1340   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1341   r = guestfs_is_file (g, path);
1342   (*env)->ReleaseStringUTFChars (env, jpath, path);
1343   if (r == -1) {
1344     throw_exception (env, guestfs_last_error (g));
1345     return 0;
1346   }
1347   return (jboolean) r;
1348 }
1349
1350 JNIEXPORT jboolean JNICALL
1351 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
1352   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1353 {
1354   guestfs_h *g = (guestfs_h *) (long) jg;
1355   int r;
1356   const char *path;
1357
1358   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1359   r = guestfs_is_dir (g, path);
1360   (*env)->ReleaseStringUTFChars (env, jpath, path);
1361   if (r == -1) {
1362     throw_exception (env, guestfs_last_error (g));
1363     return 0;
1364   }
1365   return (jboolean) r;
1366 }
1367
1368 JNIEXPORT void JNICALL
1369 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
1370   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1371 {
1372   guestfs_h *g = (guestfs_h *) (long) jg;
1373   int r;
1374   const char *device;
1375
1376   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1377   r = guestfs_pvcreate (g, device);
1378   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1379   if (r == -1) {
1380     throw_exception (env, guestfs_last_error (g));
1381     return ;
1382   }
1383 }
1384
1385 JNIEXPORT void JNICALL
1386 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
1387   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
1388 {
1389   guestfs_h *g = (guestfs_h *) (long) jg;
1390   int r;
1391   const char *volgroup;
1392   int physvols_len;
1393   const char **physvols;
1394   int i;
1395
1396   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
1397   physvols_len = (*env)->GetArrayLength (env, jphysvols);
1398   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
1399   for (i = 0; i < physvols_len; ++i) {
1400     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
1401     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
1402   }
1403   physvols[physvols_len] = NULL;
1404   r = guestfs_vgcreate (g, volgroup, physvols);
1405   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
1406   for (i = 0; i < physvols_len; ++i) {
1407     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
1408     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
1409   }
1410   free (physvols);
1411   if (r == -1) {
1412     throw_exception (env, guestfs_last_error (g));
1413     return ;
1414   }
1415 }
1416
1417 JNIEXPORT void JNICALL
1418 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
1419   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
1420 {
1421   guestfs_h *g = (guestfs_h *) (long) jg;
1422   int r;
1423   const char *logvol;
1424   const char *volgroup;
1425   int mbytes;
1426
1427   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
1428   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
1429   mbytes = jmbytes;
1430   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1431   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
1432   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
1433   if (r == -1) {
1434     throw_exception (env, guestfs_last_error (g));
1435     return ;
1436   }
1437 }
1438
1439 JNIEXPORT void JNICALL
1440 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
1441   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
1442 {
1443   guestfs_h *g = (guestfs_h *) (long) jg;
1444   int r;
1445   const char *fstype;
1446   const char *device;
1447
1448   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
1449   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1450   r = guestfs_mkfs (g, fstype, device);
1451   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
1452   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1453   if (r == -1) {
1454     throw_exception (env, guestfs_last_error (g));
1455     return ;
1456   }
1457 }
1458
1459 JNIEXPORT void JNICALL
1460 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
1461   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
1462 {
1463   guestfs_h *g = (guestfs_h *) (long) jg;
1464   int r;
1465   const char *device;
1466   int cyls;
1467   int heads;
1468   int sectors;
1469   int lines_len;
1470   const char **lines;
1471   int i;
1472
1473   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1474   cyls = jcyls;
1475   heads = jheads;
1476   sectors = jsectors;
1477   lines_len = (*env)->GetArrayLength (env, jlines);
1478   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
1479   for (i = 0; i < lines_len; ++i) {
1480     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
1481     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
1482   }
1483   lines[lines_len] = NULL;
1484   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1485   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1486   for (i = 0; i < lines_len; ++i) {
1487     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
1488     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
1489   }
1490   free (lines);
1491   if (r == -1) {
1492     throw_exception (env, guestfs_last_error (g));
1493     return ;
1494   }
1495 }
1496
1497 JNIEXPORT void JNICALL
1498 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
1499   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
1500 {
1501   guestfs_h *g = (guestfs_h *) (long) jg;
1502   int r;
1503   const char *path;
1504   const char *content;
1505   int size;
1506
1507   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1508   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
1509   size = jsize;
1510   r = guestfs_write_file (g, path, content, size);
1511   (*env)->ReleaseStringUTFChars (env, jpath, path);
1512   (*env)->ReleaseStringUTFChars (env, jcontent, content);
1513   if (r == -1) {
1514     throw_exception (env, guestfs_last_error (g));
1515     return ;
1516   }
1517 }
1518
1519 JNIEXPORT void JNICALL
1520 Java_com_redhat_et_libguestfs_GuestFS__1umount
1521   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
1522 {
1523   guestfs_h *g = (guestfs_h *) (long) jg;
1524   int r;
1525   const char *pathordevice;
1526
1527   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
1528   r = guestfs_umount (g, pathordevice);
1529   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
1530   if (r == -1) {
1531     throw_exception (env, guestfs_last_error (g));
1532     return ;
1533   }
1534 }
1535
1536 JNIEXPORT jobjectArray JNICALL
1537 Java_com_redhat_et_libguestfs_GuestFS__1mounts
1538   (JNIEnv *env, jobject obj, jlong jg)
1539 {
1540   guestfs_h *g = (guestfs_h *) (long) jg;
1541   jobjectArray jr;
1542   int r_len;
1543   jclass cl;
1544   jstring jstr;
1545   char **r;
1546   int i;
1547
1548   r = guestfs_mounts (g);
1549   if (r == NULL) {
1550     throw_exception (env, guestfs_last_error (g));
1551     return NULL;
1552   }
1553   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1554   cl = (*env)->FindClass (env, "java/lang/String");
1555   jstr = (*env)->NewStringUTF (env, "");
1556   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1557   for (i = 0; i < r_len; ++i) {
1558     jstr = (*env)->NewStringUTF (env, r[i]);
1559     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1560     free (r[i]);
1561   }
1562   free (r);
1563   return jr;
1564 }
1565
1566 JNIEXPORT void JNICALL
1567 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
1568   (JNIEnv *env, jobject obj, jlong jg)
1569 {
1570   guestfs_h *g = (guestfs_h *) (long) jg;
1571   int r;
1572
1573   r = guestfs_umount_all (g);
1574   if (r == -1) {
1575     throw_exception (env, guestfs_last_error (g));
1576     return ;
1577   }
1578 }
1579
1580 JNIEXPORT void JNICALL
1581 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
1582   (JNIEnv *env, jobject obj, jlong jg)
1583 {
1584   guestfs_h *g = (guestfs_h *) (long) jg;
1585   int r;
1586
1587   r = guestfs_lvm_remove_all (g);
1588   if (r == -1) {
1589     throw_exception (env, guestfs_last_error (g));
1590     return ;
1591   }
1592 }
1593
1594 JNIEXPORT jstring JNICALL
1595 Java_com_redhat_et_libguestfs_GuestFS__1file
1596   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1597 {
1598   guestfs_h *g = (guestfs_h *) (long) jg;
1599   jstring jr;
1600   char *r;
1601   const char *path;
1602
1603   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1604   r = guestfs_file (g, path);
1605   (*env)->ReleaseStringUTFChars (env, jpath, path);
1606   if (r == NULL) {
1607     throw_exception (env, guestfs_last_error (g));
1608     return NULL;
1609   }
1610   jr = (*env)->NewStringUTF (env, r);
1611   free (r);
1612   return jr;
1613 }
1614
1615 JNIEXPORT jstring JNICALL
1616 Java_com_redhat_et_libguestfs_GuestFS__1command
1617   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
1618 {
1619   guestfs_h *g = (guestfs_h *) (long) jg;
1620   jstring jr;
1621   char *r;
1622   int arguments_len;
1623   const char **arguments;
1624   int i;
1625
1626   arguments_len = (*env)->GetArrayLength (env, jarguments);
1627   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
1628   for (i = 0; i < arguments_len; ++i) {
1629     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1630     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
1631   }
1632   arguments[arguments_len] = NULL;
1633   r = guestfs_command (g, arguments);
1634   for (i = 0; i < arguments_len; ++i) {
1635     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1636     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
1637   }
1638   free (arguments);
1639   if (r == NULL) {
1640     throw_exception (env, guestfs_last_error (g));
1641     return NULL;
1642   }
1643   jr = (*env)->NewStringUTF (env, r);
1644   free (r);
1645   return jr;
1646 }
1647
1648 JNIEXPORT jobjectArray JNICALL
1649 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
1650   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
1651 {
1652   guestfs_h *g = (guestfs_h *) (long) jg;
1653   jobjectArray jr;
1654   int r_len;
1655   jclass cl;
1656   jstring jstr;
1657   char **r;
1658   int arguments_len;
1659   const char **arguments;
1660   int i;
1661
1662   arguments_len = (*env)->GetArrayLength (env, jarguments);
1663   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
1664   for (i = 0; i < arguments_len; ++i) {
1665     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1666     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
1667   }
1668   arguments[arguments_len] = NULL;
1669   r = guestfs_command_lines (g, arguments);
1670   for (i = 0; i < arguments_len; ++i) {
1671     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1672     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
1673   }
1674   free (arguments);
1675   if (r == NULL) {
1676     throw_exception (env, guestfs_last_error (g));
1677     return NULL;
1678   }
1679   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1680   cl = (*env)->FindClass (env, "java/lang/String");
1681   jstr = (*env)->NewStringUTF (env, "");
1682   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1683   for (i = 0; i < r_len; ++i) {
1684     jstr = (*env)->NewStringUTF (env, r[i]);
1685     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1686     free (r[i]);
1687   }
1688   free (r);
1689   return jr;
1690 }
1691
1692 JNIEXPORT jobject JNICALL
1693 Java_com_redhat_et_libguestfs_GuestFS__1stat
1694   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1695 {
1696   guestfs_h *g = (guestfs_h *) (long) jg;
1697   jobject jr;
1698   jclass cl;
1699   jfieldID fl;
1700   struct guestfs_stat *r;
1701   const char *path;
1702
1703   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1704   r = guestfs_stat (g, path);
1705   (*env)->ReleaseStringUTFChars (env, jpath, path);
1706   if (r == NULL) {
1707     throw_exception (env, guestfs_last_error (g));
1708     return NULL;
1709   }
1710   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
1711   jr = (*env)->AllocObject (env, cl);
1712   fl = (*env)->GetFieldID (env, cl, "dev", "J");
1713   (*env)->SetLongField (env, jr, fl, r->dev);
1714   fl = (*env)->GetFieldID (env, cl, "ino", "J");
1715   (*env)->SetLongField (env, jr, fl, r->ino);
1716   fl = (*env)->GetFieldID (env, cl, "mode", "J");
1717   (*env)->SetLongField (env, jr, fl, r->mode);
1718   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
1719   (*env)->SetLongField (env, jr, fl, r->nlink);
1720   fl = (*env)->GetFieldID (env, cl, "uid", "J");
1721   (*env)->SetLongField (env, jr, fl, r->uid);
1722   fl = (*env)->GetFieldID (env, cl, "gid", "J");
1723   (*env)->SetLongField (env, jr, fl, r->gid);
1724   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
1725   (*env)->SetLongField (env, jr, fl, r->rdev);
1726   fl = (*env)->GetFieldID (env, cl, "size", "J");
1727   (*env)->SetLongField (env, jr, fl, r->size);
1728   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
1729   (*env)->SetLongField (env, jr, fl, r->blksize);
1730   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1731   (*env)->SetLongField (env, jr, fl, r->blocks);
1732   fl = (*env)->GetFieldID (env, cl, "atime", "J");
1733   (*env)->SetLongField (env, jr, fl, r->atime);
1734   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
1735   (*env)->SetLongField (env, jr, fl, r->mtime);
1736   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
1737   (*env)->SetLongField (env, jr, fl, r->ctime);
1738   free (r);
1739   return jr;
1740 }
1741
1742 JNIEXPORT jobject JNICALL
1743 Java_com_redhat_et_libguestfs_GuestFS__1lstat
1744   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1745 {
1746   guestfs_h *g = (guestfs_h *) (long) jg;
1747   jobject jr;
1748   jclass cl;
1749   jfieldID fl;
1750   struct guestfs_stat *r;
1751   const char *path;
1752
1753   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1754   r = guestfs_lstat (g, path);
1755   (*env)->ReleaseStringUTFChars (env, jpath, path);
1756   if (r == NULL) {
1757     throw_exception (env, guestfs_last_error (g));
1758     return NULL;
1759   }
1760   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
1761   jr = (*env)->AllocObject (env, cl);
1762   fl = (*env)->GetFieldID (env, cl, "dev", "J");
1763   (*env)->SetLongField (env, jr, fl, r->dev);
1764   fl = (*env)->GetFieldID (env, cl, "ino", "J");
1765   (*env)->SetLongField (env, jr, fl, r->ino);
1766   fl = (*env)->GetFieldID (env, cl, "mode", "J");
1767   (*env)->SetLongField (env, jr, fl, r->mode);
1768   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
1769   (*env)->SetLongField (env, jr, fl, r->nlink);
1770   fl = (*env)->GetFieldID (env, cl, "uid", "J");
1771   (*env)->SetLongField (env, jr, fl, r->uid);
1772   fl = (*env)->GetFieldID (env, cl, "gid", "J");
1773   (*env)->SetLongField (env, jr, fl, r->gid);
1774   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
1775   (*env)->SetLongField (env, jr, fl, r->rdev);
1776   fl = (*env)->GetFieldID (env, cl, "size", "J");
1777   (*env)->SetLongField (env, jr, fl, r->size);
1778   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
1779   (*env)->SetLongField (env, jr, fl, r->blksize);
1780   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1781   (*env)->SetLongField (env, jr, fl, r->blocks);
1782   fl = (*env)->GetFieldID (env, cl, "atime", "J");
1783   (*env)->SetLongField (env, jr, fl, r->atime);
1784   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
1785   (*env)->SetLongField (env, jr, fl, r->mtime);
1786   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
1787   (*env)->SetLongField (env, jr, fl, r->ctime);
1788   free (r);
1789   return jr;
1790 }
1791
1792 JNIEXPORT jobject JNICALL
1793 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
1794   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1795 {
1796   guestfs_h *g = (guestfs_h *) (long) jg;
1797   jobject jr;
1798   jclass cl;
1799   jfieldID fl;
1800   struct guestfs_statvfs *r;
1801   const char *path;
1802
1803   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1804   r = guestfs_statvfs (g, path);
1805   (*env)->ReleaseStringUTFChars (env, jpath, path);
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/StatVFS");
1811   jr = (*env)->AllocObject (env, cl);
1812   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
1813   (*env)->SetLongField (env, jr, fl, r->bsize);
1814   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
1815   (*env)->SetLongField (env, jr, fl, r->frsize);
1816   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1817   (*env)->SetLongField (env, jr, fl, r->blocks);
1818   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
1819   (*env)->SetLongField (env, jr, fl, r->bfree);
1820   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
1821   (*env)->SetLongField (env, jr, fl, r->bavail);
1822   fl = (*env)->GetFieldID (env, cl, "files", "J");
1823   (*env)->SetLongField (env, jr, fl, r->files);
1824   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
1825   (*env)->SetLongField (env, jr, fl, r->ffree);
1826   fl = (*env)->GetFieldID (env, cl, "favail", "J");
1827   (*env)->SetLongField (env, jr, fl, r->favail);
1828   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
1829   (*env)->SetLongField (env, jr, fl, r->fsid);
1830   fl = (*env)->GetFieldID (env, cl, "flag", "J");
1831   (*env)->SetLongField (env, jr, fl, r->flag);
1832   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
1833   (*env)->SetLongField (env, jr, fl, r->namemax);
1834   free (r);
1835   return jr;
1836 }
1837
1838 JNIEXPORT jobject JNICALL
1839 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
1840   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1841 {
1842   guestfs_h *g = (guestfs_h *) (long) jg;
1843   char **r;
1844   const char *device;
1845
1846   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1847   r = guestfs_tune2fs_l (g, device);
1848   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1849   if (r == NULL) {
1850     throw_exception (env, guestfs_last_error (g));
1851     return NULL;
1852   }
1853   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1854   return NULL;
1855 }
1856
1857 JNIEXPORT void JNICALL
1858 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
1859   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1860 {
1861   guestfs_h *g = (guestfs_h *) (long) jg;
1862   int r;
1863   const char *device;
1864
1865   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1866   r = guestfs_blockdev_setro (g, device);
1867   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1868   if (r == -1) {
1869     throw_exception (env, guestfs_last_error (g));
1870     return ;
1871   }
1872 }
1873
1874 JNIEXPORT void JNICALL
1875 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
1876   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1877 {
1878   guestfs_h *g = (guestfs_h *) (long) jg;
1879   int r;
1880   const char *device;
1881
1882   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1883   r = guestfs_blockdev_setrw (g, device);
1884   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1885   if (r == -1) {
1886     throw_exception (env, guestfs_last_error (g));
1887     return ;
1888   }
1889 }
1890
1891 JNIEXPORT jboolean JNICALL
1892 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
1893   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1894 {
1895   guestfs_h *g = (guestfs_h *) (long) jg;
1896   int r;
1897   const char *device;
1898
1899   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1900   r = guestfs_blockdev_getro (g, device);
1901   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1902   if (r == -1) {
1903     throw_exception (env, guestfs_last_error (g));
1904     return 0;
1905   }
1906   return (jboolean) r;
1907 }
1908
1909 JNIEXPORT jint JNICALL
1910 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
1911   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1912 {
1913   guestfs_h *g = (guestfs_h *) (long) jg;
1914   int r;
1915   const char *device;
1916
1917   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1918   r = guestfs_blockdev_getss (g, device);
1919   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1920   if (r == -1) {
1921     throw_exception (env, guestfs_last_error (g));
1922     return 0;
1923   }
1924   return (jint) r;
1925 }
1926
1927 JNIEXPORT jint JNICALL
1928 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
1929   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1930 {
1931   guestfs_h *g = (guestfs_h *) (long) jg;
1932   int r;
1933   const char *device;
1934
1935   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1936   r = guestfs_blockdev_getbsz (g, device);
1937   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1938   if (r == -1) {
1939     throw_exception (env, guestfs_last_error (g));
1940     return 0;
1941   }
1942   return (jint) r;
1943 }
1944
1945 JNIEXPORT void JNICALL
1946 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
1947   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
1948 {
1949   guestfs_h *g = (guestfs_h *) (long) jg;
1950   int r;
1951   const char *device;
1952   int blocksize;
1953
1954   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1955   blocksize = jblocksize;
1956   r = guestfs_blockdev_setbsz (g, device, blocksize);
1957   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1958   if (r == -1) {
1959     throw_exception (env, guestfs_last_error (g));
1960     return ;
1961   }
1962 }
1963
1964 JNIEXPORT jlong JNICALL
1965 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
1966   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1967 {
1968   guestfs_h *g = (guestfs_h *) (long) jg;
1969   int64_t r;
1970   const char *device;
1971
1972   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1973   r = guestfs_blockdev_getsz (g, device);
1974   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1975   if (r == -1) {
1976     throw_exception (env, guestfs_last_error (g));
1977     return 0;
1978   }
1979   return (jlong) r;
1980 }
1981
1982 JNIEXPORT jlong JNICALL
1983 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
1984   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1985 {
1986   guestfs_h *g = (guestfs_h *) (long) jg;
1987   int64_t r;
1988   const char *device;
1989
1990   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1991   r = guestfs_blockdev_getsize64 (g, device);
1992   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1993   if (r == -1) {
1994     throw_exception (env, guestfs_last_error (g));
1995     return 0;
1996   }
1997   return (jlong) r;
1998 }
1999
2000 JNIEXPORT void JNICALL
2001 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
2002   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2003 {
2004   guestfs_h *g = (guestfs_h *) (long) jg;
2005   int r;
2006   const char *device;
2007
2008   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2009   r = guestfs_blockdev_flushbufs (g, device);
2010   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2011   if (r == -1) {
2012     throw_exception (env, guestfs_last_error (g));
2013     return ;
2014   }
2015 }
2016
2017 JNIEXPORT void JNICALL
2018 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
2019   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2020 {
2021   guestfs_h *g = (guestfs_h *) (long) jg;
2022   int r;
2023   const char *device;
2024
2025   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2026   r = guestfs_blockdev_rereadpt (g, device);
2027   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2028   if (r == -1) {
2029     throw_exception (env, guestfs_last_error (g));
2030     return ;
2031   }
2032 }
2033
2034 JNIEXPORT void JNICALL
2035 Java_com_redhat_et_libguestfs_GuestFS__1upload
2036   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
2037 {
2038   guestfs_h *g = (guestfs_h *) (long) jg;
2039   int r;
2040   const char *filename;
2041   const char *remotefilename;
2042
2043   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
2044   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
2045   r = guestfs_upload (g, filename, remotefilename);
2046   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
2047   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
2048   if (r == -1) {
2049     throw_exception (env, guestfs_last_error (g));
2050     return ;
2051   }
2052 }
2053
2054 JNIEXPORT void JNICALL
2055 Java_com_redhat_et_libguestfs_GuestFS__1download
2056   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
2057 {
2058   guestfs_h *g = (guestfs_h *) (long) jg;
2059   int r;
2060   const char *remotefilename;
2061   const char *filename;
2062
2063   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
2064   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
2065   r = guestfs_download (g, remotefilename, filename);
2066   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
2067   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
2068   if (r == -1) {
2069     throw_exception (env, guestfs_last_error (g));
2070     return ;
2071   }
2072 }
2073
2074 JNIEXPORT jstring JNICALL
2075 Java_com_redhat_et_libguestfs_GuestFS__1checksum
2076   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
2077 {
2078   guestfs_h *g = (guestfs_h *) (long) jg;
2079   jstring jr;
2080   char *r;
2081   const char *csumtype;
2082   const char *path;
2083
2084   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
2085   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2086   r = guestfs_checksum (g, csumtype, path);
2087   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
2088   (*env)->ReleaseStringUTFChars (env, jpath, path);
2089   if (r == NULL) {
2090     throw_exception (env, guestfs_last_error (g));
2091     return NULL;
2092   }
2093   jr = (*env)->NewStringUTF (env, r);
2094   free (r);
2095   return jr;
2096 }
2097
2098 JNIEXPORT void JNICALL
2099 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
2100   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
2101 {
2102   guestfs_h *g = (guestfs_h *) (long) jg;
2103   int r;
2104   const char *tarfile;
2105   const char *directory;
2106
2107   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
2108   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2109   r = guestfs_tar_in (g, tarfile, directory);
2110   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
2111   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2112   if (r == -1) {
2113     throw_exception (env, guestfs_last_error (g));
2114     return ;
2115   }
2116 }
2117
2118 JNIEXPORT void JNICALL
2119 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
2120   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
2121 {
2122   guestfs_h *g = (guestfs_h *) (long) jg;
2123   int r;
2124   const char *directory;
2125   const char *tarfile;
2126
2127   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2128   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
2129   r = guestfs_tar_out (g, directory, tarfile);
2130   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2131   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
2132   if (r == -1) {
2133     throw_exception (env, guestfs_last_error (g));
2134     return ;
2135   }
2136 }
2137
2138 JNIEXPORT void JNICALL
2139 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
2140   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
2141 {
2142   guestfs_h *g = (guestfs_h *) (long) jg;
2143   int r;
2144   const char *tarball;
2145   const char *directory;
2146
2147   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
2148   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2149   r = guestfs_tgz_in (g, tarball, directory);
2150   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
2151   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2152   if (r == -1) {
2153     throw_exception (env, guestfs_last_error (g));
2154     return ;
2155   }
2156 }
2157
2158 JNIEXPORT void JNICALL
2159 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
2160   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
2161 {
2162   guestfs_h *g = (guestfs_h *) (long) jg;
2163   int r;
2164   const char *directory;
2165   const char *tarball;
2166
2167   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2168   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
2169   r = guestfs_tgz_out (g, directory, tarball);
2170   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2171   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
2172   if (r == -1) {
2173     throw_exception (env, guestfs_last_error (g));
2174     return ;
2175   }
2176 }
2177
2178 JNIEXPORT void JNICALL
2179 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
2180   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
2181 {
2182   guestfs_h *g = (guestfs_h *) (long) jg;
2183   int r;
2184   const char *device;
2185   const char *mountpoint;
2186
2187   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2188   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
2189   r = guestfs_mount_ro (g, device, mountpoint);
2190   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2191   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
2192   if (r == -1) {
2193     throw_exception (env, guestfs_last_error (g));
2194     return ;
2195   }
2196 }
2197
2198 JNIEXPORT void JNICALL
2199 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
2200   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
2201 {
2202   guestfs_h *g = (guestfs_h *) (long) jg;
2203   int r;
2204   const char *options;
2205   const char *device;
2206   const char *mountpoint;
2207
2208   options = (*env)->GetStringUTFChars (env, joptions, NULL);
2209   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2210   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
2211   r = guestfs_mount_options (g, options, device, mountpoint);
2212   (*env)->ReleaseStringUTFChars (env, joptions, options);
2213   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2214   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
2215   if (r == -1) {
2216     throw_exception (env, guestfs_last_error (g));
2217     return ;
2218   }
2219 }
2220
2221 JNIEXPORT void JNICALL
2222 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
2223   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
2224 {
2225   guestfs_h *g = (guestfs_h *) (long) jg;
2226   int r;
2227   const char *options;
2228   const char *vfstype;
2229   const char *device;
2230   const char *mountpoint;
2231
2232   options = (*env)->GetStringUTFChars (env, joptions, NULL);
2233   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
2234   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2235   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
2236   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2237   (*env)->ReleaseStringUTFChars (env, joptions, options);
2238   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
2239   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2240   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
2241   if (r == -1) {
2242     throw_exception (env, guestfs_last_error (g));
2243     return ;
2244   }
2245 }
2246
2247 JNIEXPORT jstring JNICALL
2248 Java_com_redhat_et_libguestfs_GuestFS__1debug
2249   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
2250 {
2251   guestfs_h *g = (guestfs_h *) (long) jg;
2252   jstring jr;
2253   char *r;
2254   const char *subcmd;
2255   int extraargs_len;
2256   const char **extraargs;
2257   int i;
2258
2259   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
2260   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
2261   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
2262   for (i = 0; i < extraargs_len; ++i) {
2263     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
2264     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
2265   }
2266   extraargs[extraargs_len] = NULL;
2267   r = guestfs_debug (g, subcmd, extraargs);
2268   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
2269   for (i = 0; i < extraargs_len; ++i) {
2270     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
2271     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
2272   }
2273   free (extraargs);
2274   if (r == NULL) {
2275     throw_exception (env, guestfs_last_error (g));
2276     return NULL;
2277   }
2278   jr = (*env)->NewStringUTF (env, r);
2279   free (r);
2280   return jr;
2281 }
2282
2283 JNIEXPORT void JNICALL
2284 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
2285   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2286 {
2287   guestfs_h *g = (guestfs_h *) (long) jg;
2288   int r;
2289   const char *device;
2290
2291   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2292   r = guestfs_lvremove (g, device);
2293   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2294   if (r == -1) {
2295     throw_exception (env, guestfs_last_error (g));
2296     return ;
2297   }
2298 }
2299
2300 JNIEXPORT void JNICALL
2301 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
2302   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
2303 {
2304   guestfs_h *g = (guestfs_h *) (long) jg;
2305   int r;
2306   const char *vgname;
2307
2308   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
2309   r = guestfs_vgremove (g, vgname);
2310   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
2311   if (r == -1) {
2312     throw_exception (env, guestfs_last_error (g));
2313     return ;
2314   }
2315 }
2316
2317 JNIEXPORT void JNICALL
2318 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
2319   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2320 {
2321   guestfs_h *g = (guestfs_h *) (long) jg;
2322   int r;
2323   const char *device;
2324
2325   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2326   r = guestfs_pvremove (g, device);
2327   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2328   if (r == -1) {
2329     throw_exception (env, guestfs_last_error (g));
2330     return ;
2331   }
2332 }
2333
2334 JNIEXPORT void JNICALL
2335 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
2336   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
2337 {
2338   guestfs_h *g = (guestfs_h *) (long) jg;
2339   int r;
2340   const char *device;
2341   const char *label;
2342
2343   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2344   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2345   r = guestfs_set_e2label (g, device, label);
2346   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2347   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2348   if (r == -1) {
2349     throw_exception (env, guestfs_last_error (g));
2350     return ;
2351   }
2352 }
2353
2354 JNIEXPORT jstring JNICALL
2355 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
2356   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2357 {
2358   guestfs_h *g = (guestfs_h *) (long) jg;
2359   jstring jr;
2360   char *r;
2361   const char *device;
2362
2363   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2364   r = guestfs_get_e2label (g, device);
2365   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2366   if (r == NULL) {
2367     throw_exception (env, guestfs_last_error (g));
2368     return NULL;
2369   }
2370   jr = (*env)->NewStringUTF (env, r);
2371   free (r);
2372   return jr;
2373 }
2374
2375 JNIEXPORT void JNICALL
2376 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
2377   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
2378 {
2379   guestfs_h *g = (guestfs_h *) (long) jg;
2380   int r;
2381   const char *device;
2382   const char *uuid;
2383
2384   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2385   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
2386   r = guestfs_set_e2uuid (g, device, uuid);
2387   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2388   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
2389   if (r == -1) {
2390     throw_exception (env, guestfs_last_error (g));
2391     return ;
2392   }
2393 }
2394
2395 JNIEXPORT jstring JNICALL
2396 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
2397   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2398 {
2399   guestfs_h *g = (guestfs_h *) (long) jg;
2400   jstring jr;
2401   char *r;
2402   const char *device;
2403
2404   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2405   r = guestfs_get_e2uuid (g, device);
2406   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2407   if (r == NULL) {
2408     throw_exception (env, guestfs_last_error (g));
2409     return NULL;
2410   }
2411   jr = (*env)->NewStringUTF (env, r);
2412   free (r);
2413   return jr;
2414 }
2415
2416 JNIEXPORT jint JNICALL
2417 Java_com_redhat_et_libguestfs_GuestFS__1fsck
2418   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2419 {
2420   guestfs_h *g = (guestfs_h *) (long) jg;
2421   int r;
2422   const char *fstype;
2423   const char *device;
2424
2425   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2426   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2427   r = guestfs_fsck (g, fstype, device);
2428   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2429   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2430   if (r == -1) {
2431     throw_exception (env, guestfs_last_error (g));
2432     return 0;
2433   }
2434   return (jint) r;
2435 }
2436
2437 JNIEXPORT void JNICALL
2438 Java_com_redhat_et_libguestfs_GuestFS__1zero
2439   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2440 {
2441   guestfs_h *g = (guestfs_h *) (long) jg;
2442   int r;
2443   const char *device;
2444
2445   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2446   r = guestfs_zero (g, device);
2447   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2448   if (r == -1) {
2449     throw_exception (env, guestfs_last_error (g));
2450     return ;
2451   }
2452 }
2453
2454 JNIEXPORT void JNICALL
2455 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
2456   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
2457 {
2458   guestfs_h *g = (guestfs_h *) (long) jg;
2459   int r;
2460   const char *root;
2461   const char *device;
2462
2463   root = (*env)->GetStringUTFChars (env, jroot, NULL);
2464   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2465   r = guestfs_grub_install (g, root, device);
2466   (*env)->ReleaseStringUTFChars (env, jroot, root);
2467   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2468   if (r == -1) {
2469     throw_exception (env, guestfs_last_error (g));
2470     return ;
2471   }
2472 }
2473
2474 JNIEXPORT void JNICALL
2475 Java_com_redhat_et_libguestfs_GuestFS__1cp
2476   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2477 {
2478   guestfs_h *g = (guestfs_h *) (long) jg;
2479   int r;
2480   const char *src;
2481   const char *dest;
2482
2483   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2484   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2485   r = guestfs_cp (g, src, dest);
2486   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2487   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2488   if (r == -1) {
2489     throw_exception (env, guestfs_last_error (g));
2490     return ;
2491   }
2492 }
2493
2494 JNIEXPORT void JNICALL
2495 Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
2496   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2497 {
2498   guestfs_h *g = (guestfs_h *) (long) jg;
2499   int r;
2500   const char *src;
2501   const char *dest;
2502
2503   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2504   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2505   r = guestfs_cp_a (g, src, dest);
2506   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2507   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2508   if (r == -1) {
2509     throw_exception (env, guestfs_last_error (g));
2510     return ;
2511   }
2512 }
2513
2514 JNIEXPORT void JNICALL
2515 Java_com_redhat_et_libguestfs_GuestFS__1mv
2516   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2517 {
2518   guestfs_h *g = (guestfs_h *) (long) jg;
2519   int r;
2520   const char *src;
2521   const char *dest;
2522
2523   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2524   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2525   r = guestfs_mv (g, src, dest);
2526   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2527   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2528   if (r == -1) {
2529     throw_exception (env, guestfs_last_error (g));
2530     return ;
2531   }
2532 }
2533
2534 JNIEXPORT void JNICALL
2535 Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
2536   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
2537 {
2538   guestfs_h *g = (guestfs_h *) (long) jg;
2539   int r;
2540   int whattodrop;
2541
2542   whattodrop = jwhattodrop;
2543   r = guestfs_drop_caches (g, whattodrop);
2544   if (r == -1) {
2545     throw_exception (env, guestfs_last_error (g));
2546     return ;
2547   }
2548 }
2549
2550 JNIEXPORT jstring JNICALL
2551 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
2552   (JNIEnv *env, jobject obj, jlong jg)
2553 {
2554   guestfs_h *g = (guestfs_h *) (long) jg;
2555   jstring jr;
2556   char *r;
2557
2558   r = guestfs_dmesg (g);
2559   if (r == NULL) {
2560     throw_exception (env, guestfs_last_error (g));
2561     return NULL;
2562   }
2563   jr = (*env)->NewStringUTF (env, r);
2564   free (r);
2565   return jr;
2566 }
2567
2568 JNIEXPORT void JNICALL
2569 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
2570   (JNIEnv *env, jobject obj, jlong jg)
2571 {
2572   guestfs_h *g = (guestfs_h *) (long) jg;
2573   int r;
2574
2575   r = guestfs_ping_daemon (g);
2576   if (r == -1) {
2577     throw_exception (env, guestfs_last_error (g));
2578     return ;
2579   }
2580 }
2581
2582 JNIEXPORT jboolean JNICALL
2583 Java_com_redhat_et_libguestfs_GuestFS__1equal
2584   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
2585 {
2586   guestfs_h *g = (guestfs_h *) (long) jg;
2587   int r;
2588   const char *file1;
2589   const char *file2;
2590
2591   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
2592   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
2593   r = guestfs_equal (g, file1, file2);
2594   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
2595   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
2596   if (r == -1) {
2597     throw_exception (env, guestfs_last_error (g));
2598     return 0;
2599   }
2600   return (jboolean) r;
2601 }
2602
2603 JNIEXPORT jobjectArray JNICALL
2604 Java_com_redhat_et_libguestfs_GuestFS__1strings
2605   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2606 {
2607   guestfs_h *g = (guestfs_h *) (long) jg;
2608   jobjectArray jr;
2609   int r_len;
2610   jclass cl;
2611   jstring jstr;
2612   char **r;
2613   const char *path;
2614   int i;
2615
2616   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2617   r = guestfs_strings (g, path);
2618   (*env)->ReleaseStringUTFChars (env, jpath, path);
2619   if (r == NULL) {
2620     throw_exception (env, guestfs_last_error (g));
2621     return NULL;
2622   }
2623   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2624   cl = (*env)->FindClass (env, "java/lang/String");
2625   jstr = (*env)->NewStringUTF (env, "");
2626   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2627   for (i = 0; i < r_len; ++i) {
2628     jstr = (*env)->NewStringUTF (env, r[i]);
2629     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2630     free (r[i]);
2631   }
2632   free (r);
2633   return jr;
2634 }
2635
2636 JNIEXPORT jobjectArray JNICALL
2637 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
2638   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
2639 {
2640   guestfs_h *g = (guestfs_h *) (long) jg;
2641   jobjectArray jr;
2642   int r_len;
2643   jclass cl;
2644   jstring jstr;
2645   char **r;
2646   const char *encoding;
2647   const char *path;
2648   int i;
2649
2650   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
2651   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2652   r = guestfs_strings_e (g, encoding, path);
2653   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
2654   (*env)->ReleaseStringUTFChars (env, jpath, path);
2655   if (r == NULL) {
2656     throw_exception (env, guestfs_last_error (g));
2657     return NULL;
2658   }
2659   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2660   cl = (*env)->FindClass (env, "java/lang/String");
2661   jstr = (*env)->NewStringUTF (env, "");
2662   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2663   for (i = 0; i < r_len; ++i) {
2664     jstr = (*env)->NewStringUTF (env, r[i]);
2665     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2666     free (r[i]);
2667   }
2668   free (r);
2669   return jr;
2670 }
2671
2672 JNIEXPORT jstring JNICALL
2673 Java_com_redhat_et_libguestfs_GuestFS__1hexdump
2674   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2675 {
2676   guestfs_h *g = (guestfs_h *) (long) jg;
2677   jstring jr;
2678   char *r;
2679   const char *path;
2680
2681   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2682   r = guestfs_hexdump (g, path);
2683   (*env)->ReleaseStringUTFChars (env, jpath, path);
2684   if (r == NULL) {
2685     throw_exception (env, guestfs_last_error (g));
2686     return NULL;
2687   }
2688   jr = (*env)->NewStringUTF (env, r);
2689   free (r);
2690   return jr;
2691 }
2692