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