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) 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 *) jg;
  61   guestfs_close (g);
  62 }
  63
  64 JNIEXPORT void JNICALL
  65 Java_com_redhat_et_libguestfs__1launch
  66   (JNIEnv *env, jobject obj, jlong jg)
  67 {
  68   guestfs_h *g = (guestfs_h *) 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__1wait_1ready
  80   (JNIEnv *env, jobject obj, jlong jg)
  81 {
  82   guestfs_h *g = (guestfs_h *) 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__1kill_1subprocess
  94   (JNIEnv *env, jobject obj, jlong jg)
  95 {
  96   guestfs_h *g = (guestfs_h *) 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__1add_1drive
 108   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
 109 {
 110   guestfs_h *g = (guestfs_h *) 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__1add_1cdrom
 125   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
 126 {
 127   guestfs_h *g = (guestfs_h *) 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__1config
 142   (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
 143 {
 144   guestfs_h *g = (guestfs_h *) 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__1set_1path
 162   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 163 {
 164   guestfs_h *g = (guestfs_h *) jg;
 165   int r;
 166   const char *path;
 167
 168   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 169   r = guestfs_set_path (g, path);
 170   (*env)->ReleaseStringUTFChars (env, jpath, path);
 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__1get_1path
 179   (JNIEnv *env, jobject obj, jlong jg)
 180 {
 181   guestfs_h *g = (guestfs_h *) jg;
 182   const char *r;
 183
 184   r = guestfs_get_path (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__1set_1autosync
 194   (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
 195 {
 196   guestfs_h *g = (guestfs_h *) jg;
 197   int r;
 198   int autosync;
 199
 200   autosync = jautosync;
 201   r = guestfs_set_autosync (g, autosync);
 202   if (r == -1) {
 203     throw_exception (env, guestfs_last_error (g));
 204     return ;
 205   }
 206 }
 207
 208 JNIEXPORT jboolean JNICALL
 209 Java_com_redhat_et_libguestfs__1get_1autosync
 210   (JNIEnv *env, jobject obj, jlong jg)
 211 {
 212   guestfs_h *g = (guestfs_h *) jg;
 213   int r;
 214
 215   r = guestfs_get_autosync (g);
 216   if (r == -1) {
 217     throw_exception (env, guestfs_last_error (g));
 218     return 0;
 219   }
 220   return (jboolean) r;
 221 }
 222
 223 JNIEXPORT void JNICALL
 224 Java_com_redhat_et_libguestfs__1set_1verbose
 225   (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
 226 {
 227   guestfs_h *g = (guestfs_h *) jg;
 228   int r;
 229   int verbose;
 230
 231   verbose = jverbose;
 232   r = guestfs_set_verbose (g, verbose);
 233   if (r == -1) {
 234     throw_exception (env, guestfs_last_error (g));
 235     return ;
 236   }
 237 }
 238
 239 JNIEXPORT jboolean JNICALL
 240 Java_com_redhat_et_libguestfs__1get_1verbose
 241   (JNIEnv *env, jobject obj, jlong jg)
 242 {
 243   guestfs_h *g = (guestfs_h *) jg;
 244   int r;
 245
 246   r = guestfs_get_verbose (g);
 247   if (r == -1) {
 248     throw_exception (env, guestfs_last_error (g));
 249     return 0;
 250   }
 251   return (jboolean) r;
 252 }
 253
 254 JNIEXPORT jboolean JNICALL
 255 Java_com_redhat_et_libguestfs__1is_1ready
 256   (JNIEnv *env, jobject obj, jlong jg)
 257 {
 258   guestfs_h *g = (guestfs_h *) jg;
 259   int r;
 260
 261   r = guestfs_is_ready (g);
 262   if (r == -1) {
 263     throw_exception (env, guestfs_last_error (g));
 264     return 0;
 265   }
 266   return (jboolean) r;
 267 }
 268
 269 JNIEXPORT jboolean JNICALL
 270 Java_com_redhat_et_libguestfs__1is_1config
 271   (JNIEnv *env, jobject obj, jlong jg)
 272 {
 273   guestfs_h *g = (guestfs_h *) jg;
 274   int r;
 275
 276   r = guestfs_is_config (g);
 277   if (r == -1) {
 278     throw_exception (env, guestfs_last_error (g));
 279     return 0;
 280   }
 281   return (jboolean) r;
 282 }
 283
 284 JNIEXPORT jboolean JNICALL
 285 Java_com_redhat_et_libguestfs__1is_1launching
 286   (JNIEnv *env, jobject obj, jlong jg)
 287 {
 288   guestfs_h *g = (guestfs_h *) jg;
 289   int r;
 290
 291   r = guestfs_is_launching (g);
 292   if (r == -1) {
 293     throw_exception (env, guestfs_last_error (g));
 294     return 0;
 295   }
 296   return (jboolean) r;
 297 }
 298
 299 JNIEXPORT jboolean JNICALL
 300 Java_com_redhat_et_libguestfs__1is_1busy
 301   (JNIEnv *env, jobject obj, jlong jg)
 302 {
 303   guestfs_h *g = (guestfs_h *) jg;
 304   int r;
 305
 306   r = guestfs_is_busy (g);
 307   if (r == -1) {
 308     throw_exception (env, guestfs_last_error (g));
 309     return 0;
 310   }
 311   return (jboolean) r;
 312 }
 313
 314 JNIEXPORT jint JNICALL
 315 Java_com_redhat_et_libguestfs__1get_1state
 316   (JNIEnv *env, jobject obj, jlong jg)
 317 {
 318   guestfs_h *g = (guestfs_h *) jg;
 319   int r;
 320
 321   r = guestfs_get_state (g);
 322   if (r == -1) {
 323     throw_exception (env, guestfs_last_error (g));
 324     return 0;
 325   }
 326   return (jint) r;
 327 }
 328
 329 JNIEXPORT void JNICALL
 330 Java_com_redhat_et_libguestfs__1set_1busy
 331   (JNIEnv *env, jobject obj, jlong jg)
 332 {
 333   guestfs_h *g = (guestfs_h *) jg;
 334   int r;
 335
 336   r = guestfs_set_busy (g);
 337   if (r == -1) {
 338     throw_exception (env, guestfs_last_error (g));
 339     return ;
 340   }
 341 }
 342
 343 JNIEXPORT void JNICALL
 344 Java_com_redhat_et_libguestfs__1set_1ready
 345   (JNIEnv *env, jobject obj, jlong jg)
 346 {
 347   guestfs_h *g = (guestfs_h *) jg;
 348   int r;
 349
 350   r = guestfs_set_ready (g);
 351   if (r == -1) {
 352     throw_exception (env, guestfs_last_error (g));
 353     return ;
 354   }
 355 }
 356
 357 JNIEXPORT void JNICALL
 358 Java_com_redhat_et_libguestfs__1mount
 359   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
 360 {
 361   guestfs_h *g = (guestfs_h *) jg;
 362   int r;
 363   const char *device;
 364   const char *mountpoint;
 365
 366   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
 367   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
 368   r = guestfs_mount (g, device, mountpoint);
 369   (*env)->ReleaseStringUTFChars (env, jdevice, device);
 370   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
 371   if (r == -1) {
 372     throw_exception (env, guestfs_last_error (g));
 373     return ;
 374   }
 375 }
 376
 377 JNIEXPORT void JNICALL
 378 Java_com_redhat_et_libguestfs__1sync
 379   (JNIEnv *env, jobject obj, jlong jg)
 380 {
 381   guestfs_h *g = (guestfs_h *) jg;
 382   int r;
 383
 384   r = guestfs_sync (g);
 385   if (r == -1) {
 386     throw_exception (env, guestfs_last_error (g));
 387     return ;
 388   }
 389 }
 390
 391 JNIEXPORT void JNICALL
 392 Java_com_redhat_et_libguestfs__1touch
 393   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 394 {
 395   guestfs_h *g = (guestfs_h *) jg;
 396   int r;
 397   const char *path;
 398
 399   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 400   r = guestfs_touch (g, path);
 401   (*env)->ReleaseStringUTFChars (env, jpath, path);
 402   if (r == -1) {
 403     throw_exception (env, guestfs_last_error (g));
 404     return ;
 405   }
 406 }
 407
 408 JNIEXPORT jstring JNICALL
 409 Java_com_redhat_et_libguestfs__1cat
 410   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 411 {
 412   guestfs_h *g = (guestfs_h *) jg;
 413   jstring jr;
 414   char *r;
 415   const char *path;
 416
 417   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 418   r = guestfs_cat (g, path);
 419   (*env)->ReleaseStringUTFChars (env, jpath, path);
 420   if (r == NULL) {
 421     throw_exception (env, guestfs_last_error (g));
 422     return NULL;
 423   }
 424   jr = (*env)->NewStringUTF (env, r);
 425   free (r);
 426   return jr;
 427 }
 428
 429 JNIEXPORT jstring JNICALL
 430 Java_com_redhat_et_libguestfs__1ll
 431   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
 432 {
 433   guestfs_h *g = (guestfs_h *) jg;
 434   jstring jr;
 435   char *r;
 436   const char *directory;
 437
 438   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
 439   r = guestfs_ll (g, directory);
 440   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
 441   if (r == NULL) {
 442     throw_exception (env, guestfs_last_error (g));
 443     return NULL;
 444   }
 445   jr = (*env)->NewStringUTF (env, r);
 446   free (r);
 447   return jr;
 448 }
 449
 450 JNIEXPORT jobjectArray JNICALL
 451 Java_com_redhat_et_libguestfs__1ls
 452   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
 453 {
 454   guestfs_h *g = (guestfs_h *) jg;
 455   jobjectArray jr;
 456   int r_len;
 457   jclass cl;
 458   jstring jstr;
 459   char **r;
 460   const char *directory;
 461   int i;
 462
 463   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
 464   r = guestfs_ls (g, directory);
 465   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
 466   if (r == NULL) {
 467     throw_exception (env, guestfs_last_error (g));
 468     return NULL;
 469   }
 470   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 471   cl = (*env)->FindClass (env, "java/lang/String");
 472   jstr = (*env)->NewStringUTF (env, "");
 473   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 474   for (i = 0; i < r_len; ++i) {
 475     jstr = (*env)->NewStringUTF (env, r[i]);
 476     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 477     free (r[i]);
 478   }
 479   free (r);
 480   return jr;
 481 }
 482
 483 JNIEXPORT jobjectArray JNICALL
 484 Java_com_redhat_et_libguestfs__1list_1devices
 485   (JNIEnv *env, jobject obj, jlong jg)
 486 {
 487   guestfs_h *g = (guestfs_h *) jg;
 488   jobjectArray jr;
 489   int r_len;
 490   jclass cl;
 491   jstring jstr;
 492   char **r;
 493   int i;
 494
 495   r = guestfs_list_devices (g);
 496   if (r == NULL) {
 497     throw_exception (env, guestfs_last_error (g));
 498     return NULL;
 499   }
 500   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 501   cl = (*env)->FindClass (env, "java/lang/String");
 502   jstr = (*env)->NewStringUTF (env, "");
 503   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 504   for (i = 0; i < r_len; ++i) {
 505     jstr = (*env)->NewStringUTF (env, r[i]);
 506     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 507     free (r[i]);
 508   }
 509   free (r);
 510   return jr;
 511 }
 512
 513 JNIEXPORT jobjectArray JNICALL
 514 Java_com_redhat_et_libguestfs__1list_1partitions
 515   (JNIEnv *env, jobject obj, jlong jg)
 516 {
 517   guestfs_h *g = (guestfs_h *) jg;
 518   jobjectArray jr;
 519   int r_len;
 520   jclass cl;
 521   jstring jstr;
 522   char **r;
 523   int i;
 524
 525   r = guestfs_list_partitions (g);
 526   if (r == NULL) {
 527     throw_exception (env, guestfs_last_error (g));
 528     return NULL;
 529   }
 530   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 531   cl = (*env)->FindClass (env, "java/lang/String");
 532   jstr = (*env)->NewStringUTF (env, "");
 533   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 534   for (i = 0; i < r_len; ++i) {
 535     jstr = (*env)->NewStringUTF (env, r[i]);
 536     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 537     free (r[i]);
 538   }
 539   free (r);
 540   return jr;
 541 }
 542
 543 JNIEXPORT jobjectArray JNICALL
 544 Java_com_redhat_et_libguestfs__1pvs
 545   (JNIEnv *env, jobject obj, jlong jg)
 546 {
 547   guestfs_h *g = (guestfs_h *) jg;
 548   jobjectArray jr;
 549   int r_len;
 550   jclass cl;
 551   jstring jstr;
 552   char **r;
 553   int i;
 554
 555   r = guestfs_pvs (g);
 556   if (r == NULL) {
 557     throw_exception (env, guestfs_last_error (g));
 558     return NULL;
 559   }
 560   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 561   cl = (*env)->FindClass (env, "java/lang/String");
 562   jstr = (*env)->NewStringUTF (env, "");
 563   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 564   for (i = 0; i < r_len; ++i) {
 565     jstr = (*env)->NewStringUTF (env, r[i]);
 566     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 567     free (r[i]);
 568   }
 569   free (r);
 570   return jr;
 571 }
 572
 573 JNIEXPORT jobjectArray JNICALL
 574 Java_com_redhat_et_libguestfs__1vgs
 575   (JNIEnv *env, jobject obj, jlong jg)
 576 {
 577   guestfs_h *g = (guestfs_h *) jg;
 578   jobjectArray jr;
 579   int r_len;
 580   jclass cl;
 581   jstring jstr;
 582   char **r;
 583   int i;
 584
 585   r = guestfs_vgs (g);
 586   if (r == NULL) {
 587     throw_exception (env, guestfs_last_error (g));
 588     return NULL;
 589   }
 590   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 591   cl = (*env)->FindClass (env, "java/lang/String");
 592   jstr = (*env)->NewStringUTF (env, "");
 593   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 594   for (i = 0; i < r_len; ++i) {
 595     jstr = (*env)->NewStringUTF (env, r[i]);
 596     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 597     free (r[i]);
 598   }
 599   free (r);
 600   return jr;
 601 }
 602
 603 JNIEXPORT jobjectArray JNICALL
 604 Java_com_redhat_et_libguestfs__1lvs
 605   (JNIEnv *env, jobject obj, jlong jg)
 606 {
 607   guestfs_h *g = (guestfs_h *) jg;
 608   jobjectArray jr;
 609   int r_len;
 610   jclass cl;
 611   jstring jstr;
 612   char **r;
 613   int i;
 614
 615   r = guestfs_lvs (g);
 616   if (r == NULL) {
 617     throw_exception (env, guestfs_last_error (g));
 618     return NULL;
 619   }
 620   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 621   cl = (*env)->FindClass (env, "java/lang/String");
 622   jstr = (*env)->NewStringUTF (env, "");
 623   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 624   for (i = 0; i < r_len; ++i) {
 625     jstr = (*env)->NewStringUTF (env, r[i]);
 626     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 627     free (r[i]);
 628   }
 629   free (r);
 630   return jr;
 631 }
 632
 633 JNIEXPORT jobjectArray JNICALL
 634 Java_com_redhat_et_libguestfs__1pvs_1full
 635   (JNIEnv *env, jobject obj, jlong jg)
 636 {
 637   guestfs_h *g = (guestfs_h *) jg;
 638   jobjectArray jr;
 639   jclass cl;
 640   jfieldID fl;
 641   jobject jfl;
 642   struct guestfs_lvm_pv_list *r;
 643   int i;
 644
 645   r = guestfs_pvs_full (g);
 646   if (r == NULL) {
 647     throw_exception (env, guestfs_last_error (g));
 648     return NULL;
 649   }
 650   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
 651   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 652   for (i = 0; i < r->len; ++i) {
 653     jfl = (*env)->AllocObject (env, cl);
 654     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
 655     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
 656     {
 657       char s[33];
 658       memcpy (s, r->val[i].pv_uuid, 32);
 659       s[32] = 0;
 660       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
 661       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 662     }
 663     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
 664     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
 665     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
 666     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
 667     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
 668     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
 669     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
 670     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
 671     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
 672     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
 673     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
 674     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
 675     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
 676     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
 677     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
 678     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
 679     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
 680     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
 681     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
 682     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
 683     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
 684     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
 685     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
 686     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
 687     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 688   }
 689   guestfs_free_lvm_pv_list (r);
 690   return jr;
 691 }
 692
 693 JNIEXPORT jobjectArray JNICALL
 694 Java_com_redhat_et_libguestfs__1vgs_1full
 695   (JNIEnv *env, jobject obj, jlong jg)
 696 {
 697   guestfs_h *g = (guestfs_h *) jg;
 698   jobjectArray jr;
 699   jclass cl;
 700   jfieldID fl;
 701   jobject jfl;
 702   struct guestfs_lvm_vg_list *r;
 703   int i;
 704
 705   r = guestfs_vgs_full (g);
 706   if (r == NULL) {
 707     throw_exception (env, guestfs_last_error (g));
 708     return NULL;
 709   }
 710   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
 711   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 712   for (i = 0; i < r->len; ++i) {
 713     jfl = (*env)->AllocObject (env, cl);
 714     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
 715     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
 716     {
 717       char s[33];
 718       memcpy (s, r->val[i].vg_uuid, 32);
 719       s[32] = 0;
 720       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
 721       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 722     }
 723     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
 724     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
 725     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
 726     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
 727     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
 728     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
 729     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
 730     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
 731     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
 732     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
 733     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
 734     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
 735     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
 736     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
 737     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
 738     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
 739     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
 740     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
 741     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
 742     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
 743     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
 744     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
 745     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
 746     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
 747     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
 748     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
 749     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
 750     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
 751     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
 752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
 753     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
 754     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
 755     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
 756     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
 757     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 758   }
 759   guestfs_free_lvm_vg_list (r);
 760   return jr;
 761 }
 762
 763 JNIEXPORT jobjectArray JNICALL
 764 Java_com_redhat_et_libguestfs__1lvs_1full
 765   (JNIEnv *env, jobject obj, jlong jg)
 766 {
 767   guestfs_h *g = (guestfs_h *) jg;
 768   jobjectArray jr;
 769   jclass cl;
 770   jfieldID fl;
 771   jobject jfl;
 772   struct guestfs_lvm_lv_list *r;
 773   int i;
 774
 775   r = guestfs_lvs_full (g);
 776   if (r == NULL) {
 777     throw_exception (env, guestfs_last_error (g));
 778     return NULL;
 779   }
 780   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
 781   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
 782   for (i = 0; i < r->len; ++i) {
 783     jfl = (*env)->AllocObject (env, cl);
 784     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
 785     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
 786     {
 787       char s[33];
 788       memcpy (s, r->val[i].lv_uuid, 32);
 789       s[32] = 0;
 790       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
 791       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
 792     }
 793     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
 794     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
 795     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
 796     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
 797     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
 798     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
 799     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
 800     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
 801     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
 802     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
 803     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
 804     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
 805     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
 806     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
 807     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
 808     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
 809     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
 810     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
 811     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
 812     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
 813     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
 814     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
 815     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
 816     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
 817     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
 818     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
 819     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
 820     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
 821     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
 822   }
 823   guestfs_free_lvm_lv_list (r);
 824   return jr;
 825 }
 826
 827 JNIEXPORT jobjectArray JNICALL
 828 Java_com_redhat_et_libguestfs__1read_1lines
 829   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 830 {
 831   guestfs_h *g = (guestfs_h *) jg;
 832   jobjectArray jr;
 833   int r_len;
 834   jclass cl;
 835   jstring jstr;
 836   char **r;
 837   const char *path;
 838   int i;
 839
 840   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 841   r = guestfs_read_lines (g, path);
 842   (*env)->ReleaseStringUTFChars (env, jpath, path);
 843   if (r == NULL) {
 844     throw_exception (env, guestfs_last_error (g));
 845     return NULL;
 846   }
 847   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
 848   cl = (*env)->FindClass (env, "java/lang/String");
 849   jstr = (*env)->NewStringUTF (env, "");
 850   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
 851   for (i = 0; i < r_len; ++i) {
 852     jstr = (*env)->NewStringUTF (env, r[i]);
 853     (*env)->SetObjectArrayElement (env, jr, i, jstr);
 854     free (r[i]);
 855   }
 856   free (r);
 857   return jr;
 858 }
 859
 860 JNIEXPORT void JNICALL
 861 Java_com_redhat_et_libguestfs__1aug_1init
 862   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
 863 {
 864   guestfs_h *g = (guestfs_h *) jg;
 865   int r;
 866   const char *root;
 867   int flags;
 868
 869   root = (*env)->GetStringUTFChars (env, jroot, NULL);
 870   flags = jflags;
 871   r = guestfs_aug_init (g, root, flags);
 872   (*env)->ReleaseStringUTFChars (env, jroot, root);
 873   if (r == -1) {
 874     throw_exception (env, guestfs_last_error (g));
 875     return ;
 876   }
 877 }
 878
 879 JNIEXPORT void JNICALL
 880 Java_com_redhat_et_libguestfs__1aug_1close
 881   (JNIEnv *env, jobject obj, jlong jg)
 882 {
 883   guestfs_h *g = (guestfs_h *) jg;
 884   int r;
 885
 886   r = guestfs_aug_close (g);
 887   if (r == -1) {
 888     throw_exception (env, guestfs_last_error (g));
 889     return ;
 890   }
 891 }
 892
 893 JNIEXPORT jint JNICALL
 894 Java_com_redhat_et_libguestfs__1aug_1defvar
 895   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
 896 {
 897   guestfs_h *g = (guestfs_h *) jg;
 898   int r;
 899   const char *name;
 900   const char *expr;
 901
 902   name = (*env)->GetStringUTFChars (env, jname, NULL);
 903   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
 904   r = guestfs_aug_defvar (g, name, expr);
 905   (*env)->ReleaseStringUTFChars (env, jname, name);
 906   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
 907   if (r == -1) {
 908     throw_exception (env, guestfs_last_error (g));
 909     return 0;
 910   }
 911   return (jint) r;
 912 }
 913
 914 JNIEXPORT jobject JNICALL
 915 Java_com_redhat_et_libguestfs__1aug_1defnode
 916   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
 917 {
 918   guestfs_h *g = (guestfs_h *) jg;
 919   jobject jr;
 920   jclass cl;
 921   jfieldID fl;
 922   struct guestfs_int_bool *r;
 923   const char *name;
 924   const char *expr;
 925   const char *val;
 926
 927   name = (*env)->GetStringUTFChars (env, jname, NULL);
 928   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
 929   val = (*env)->GetStringUTFChars (env, jval, NULL);
 930   r = guestfs_aug_defnode (g, name, expr, val);
 931   (*env)->ReleaseStringUTFChars (env, jname, name);
 932   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
 933   (*env)->ReleaseStringUTFChars (env, jval, val);
 934   if (r == NULL) {
 935     throw_exception (env, guestfs_last_error (g));
 936     return NULL;
 937   }
 938   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
 939   jr = (*env)->AllocObject (env, cl);
 940   fl = (*env)->GetFieldID (env, cl, "i", "I");
 941   (*env)->SetIntField (env, jr, fl, r->i);
 942   fl = (*env)->GetFieldID (env, cl, "i", "Z");
 943   (*env)->SetBooleanField (env, jr, fl, r->b);
 944   guestfs_free_int_bool (r);
 945   return jr;
 946 }
 947
 948 JNIEXPORT jstring JNICALL
 949 Java_com_redhat_et_libguestfs__1aug_1get
 950   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
 951 {
 952   guestfs_h *g = (guestfs_h *) jg;
 953   jstring jr;
 954   char *r;
 955   const char *path;
 956
 957   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 958   r = guestfs_aug_get (g, path);
 959   (*env)->ReleaseStringUTFChars (env, jpath, path);
 960   if (r == NULL) {
 961     throw_exception (env, guestfs_last_error (g));
 962     return NULL;
 963   }
 964   jr = (*env)->NewStringUTF (env, r);
 965   free (r);
 966   return jr;
 967 }
 968
 969 JNIEXPORT void JNICALL
 970 Java_com_redhat_et_libguestfs__1aug_1set
 971   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
 972 {
 973   guestfs_h *g = (guestfs_h *) jg;
 974   int r;
 975   const char *path;
 976   const char *val;
 977
 978   path = (*env)->GetStringUTFChars (env, jpath, NULL);
 979   val = (*env)->GetStringUTFChars (env, jval, NULL);
 980   r = guestfs_aug_set (g, path, val);
 981   (*env)->ReleaseStringUTFChars (env, jpath, path);
 982   (*env)->ReleaseStringUTFChars (env, jval, val);
 983   if (r == -1) {
 984     throw_exception (env, guestfs_last_error (g));
 985     return ;
 986   }
 987 }
 988
 989 JNIEXPORT void JNICALL
 990 Java_com_redhat_et_libguestfs__1aug_1insert
 991   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
 992 {
 993   guestfs_h *g = (guestfs_h *) jg;
 994   int r;
 995   const char *path;
 996   const char *label;
 997   int before;
 998
 999   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1000   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
1001   before = jbefore;
1002   r = guestfs_aug_insert (g, path, label, before);
1003   (*env)->ReleaseStringUTFChars (env, jpath, path);
1004   (*env)->ReleaseStringUTFChars (env, jlabel, label);
1005   if (r == -1) {
1006     throw_exception (env, guestfs_last_error (g));
1007     return ;
1008   }
1009 }
1010
1011 JNIEXPORT jint JNICALL
1012 Java_com_redhat_et_libguestfs__1aug_1rm
1013   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1014 {
1015   guestfs_h *g = (guestfs_h *) jg;
1016   int r;
1017   const char *path;
1018
1019   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1020   r = guestfs_aug_rm (g, path);
1021   (*env)->ReleaseStringUTFChars (env, jpath, path);
1022   if (r == -1) {
1023     throw_exception (env, guestfs_last_error (g));
1024     return 0;
1025   }
1026   return (jint) r;
1027 }
1028
1029 JNIEXPORT void JNICALL
1030 Java_com_redhat_et_libguestfs__1aug_1mv
1031   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
1032 {
1033   guestfs_h *g = (guestfs_h *) jg;
1034   int r;
1035   const char *src;
1036   const char *dest;
1037
1038   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
1039   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
1040   r = guestfs_aug_mv (g, src, dest);
1041   (*env)->ReleaseStringUTFChars (env, jsrc, src);
1042   (*env)->ReleaseStringUTFChars (env, jdest, dest);
1043   if (r == -1) {
1044     throw_exception (env, guestfs_last_error (g));
1045     return ;
1046   }
1047 }
1048
1049 JNIEXPORT jobjectArray JNICALL
1050 Java_com_redhat_et_libguestfs__1aug_1match
1051   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1052 {
1053   guestfs_h *g = (guestfs_h *) jg;
1054   jobjectArray jr;
1055   int r_len;
1056   jclass cl;
1057   jstring jstr;
1058   char **r;
1059   const char *path;
1060   int i;
1061
1062   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1063   r = guestfs_aug_match (g, path);
1064   (*env)->ReleaseStringUTFChars (env, jpath, path);
1065   if (r == NULL) {
1066     throw_exception (env, guestfs_last_error (g));
1067     return NULL;
1068   }
1069   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1070   cl = (*env)->FindClass (env, "java/lang/String");
1071   jstr = (*env)->NewStringUTF (env, "");
1072   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1073   for (i = 0; i < r_len; ++i) {
1074     jstr = (*env)->NewStringUTF (env, r[i]);
1075     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1076     free (r[i]);
1077   }
1078   free (r);
1079   return jr;
1080 }
1081
1082 JNIEXPORT void JNICALL
1083 Java_com_redhat_et_libguestfs__1aug_1save
1084   (JNIEnv *env, jobject obj, jlong jg)
1085 {
1086   guestfs_h *g = (guestfs_h *) jg;
1087   int r;
1088
1089   r = guestfs_aug_save (g);
1090   if (r == -1) {
1091     throw_exception (env, guestfs_last_error (g));
1092     return ;
1093   }
1094 }
1095
1096 JNIEXPORT void JNICALL
1097 Java_com_redhat_et_libguestfs__1aug_1load
1098   (JNIEnv *env, jobject obj, jlong jg)
1099 {
1100   guestfs_h *g = (guestfs_h *) jg;
1101   int r;
1102
1103   r = guestfs_aug_load (g);
1104   if (r == -1) {
1105     throw_exception (env, guestfs_last_error (g));
1106     return ;
1107   }
1108 }
1109
1110 JNIEXPORT jobjectArray JNICALL
1111 Java_com_redhat_et_libguestfs__1aug_1ls
1112   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1113 {
1114   guestfs_h *g = (guestfs_h *) jg;
1115   jobjectArray jr;
1116   int r_len;
1117   jclass cl;
1118   jstring jstr;
1119   char **r;
1120   const char *path;
1121   int i;
1122
1123   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1124   r = guestfs_aug_ls (g, path);
1125   (*env)->ReleaseStringUTFChars (env, jpath, path);
1126   if (r == NULL) {
1127     throw_exception (env, guestfs_last_error (g));
1128     return NULL;
1129   }
1130   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1131   cl = (*env)->FindClass (env, "java/lang/String");
1132   jstr = (*env)->NewStringUTF (env, "");
1133   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1134   for (i = 0; i < r_len; ++i) {
1135     jstr = (*env)->NewStringUTF (env, r[i]);
1136     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1137     free (r[i]);
1138   }
1139   free (r);
1140   return jr;
1141 }
1142
1143 JNIEXPORT void JNICALL
1144 Java_com_redhat_et_libguestfs__1rm
1145   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1146 {
1147   guestfs_h *g = (guestfs_h *) jg;
1148   int r;
1149   const char *path;
1150
1151   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1152   r = guestfs_rm (g, path);
1153   (*env)->ReleaseStringUTFChars (env, jpath, path);
1154   if (r == -1) {
1155     throw_exception (env, guestfs_last_error (g));
1156     return ;
1157   }
1158 }
1159
1160 JNIEXPORT void JNICALL
1161 Java_com_redhat_et_libguestfs__1rmdir
1162   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1163 {
1164   guestfs_h *g = (guestfs_h *) jg;
1165   int r;
1166   const char *path;
1167
1168   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1169   r = guestfs_rmdir (g, path);
1170   (*env)->ReleaseStringUTFChars (env, jpath, path);
1171   if (r == -1) {
1172     throw_exception (env, guestfs_last_error (g));
1173     return ;
1174   }
1175 }
1176
1177 JNIEXPORT void JNICALL
1178 Java_com_redhat_et_libguestfs__1rm_1rf
1179   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1180 {
1181   guestfs_h *g = (guestfs_h *) jg;
1182   int r;
1183   const char *path;
1184
1185   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1186   r = guestfs_rm_rf (g, path);
1187   (*env)->ReleaseStringUTFChars (env, jpath, path);
1188   if (r == -1) {
1189     throw_exception (env, guestfs_last_error (g));
1190     return ;
1191   }
1192 }
1193
1194 JNIEXPORT void JNICALL
1195 Java_com_redhat_et_libguestfs__1mkdir
1196   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1197 {
1198   guestfs_h *g = (guestfs_h *) jg;
1199   int r;
1200   const char *path;
1201
1202   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1203   r = guestfs_mkdir (g, path);
1204   (*env)->ReleaseStringUTFChars (env, jpath, path);
1205   if (r == -1) {
1206     throw_exception (env, guestfs_last_error (g));
1207     return ;
1208   }
1209 }
1210
1211 JNIEXPORT void JNICALL
1212 Java_com_redhat_et_libguestfs__1mkdir_1p
1213   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1214 {
1215   guestfs_h *g = (guestfs_h *) jg;
1216   int r;
1217   const char *path;
1218
1219   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1220   r = guestfs_mkdir_p (g, path);
1221   (*env)->ReleaseStringUTFChars (env, jpath, path);
1222   if (r == -1) {
1223     throw_exception (env, guestfs_last_error (g));
1224     return ;
1225   }
1226 }
1227
1228 JNIEXPORT void JNICALL
1229 Java_com_redhat_et_libguestfs__1chmod
1230   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
1231 {
1232   guestfs_h *g = (guestfs_h *) jg;
1233   int r;
1234   int mode;
1235   const char *path;
1236
1237   mode = jmode;
1238   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1239   r = guestfs_chmod (g, mode, path);
1240   (*env)->ReleaseStringUTFChars (env, jpath, path);
1241   if (r == -1) {
1242     throw_exception (env, guestfs_last_error (g));
1243     return ;
1244   }
1245 }
1246
1247 JNIEXPORT void JNICALL
1248 Java_com_redhat_et_libguestfs__1chown
1249   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
1250 {
1251   guestfs_h *g = (guestfs_h *) jg;
1252   int r;
1253   int owner;
1254   int group;
1255   const char *path;
1256
1257   owner = jowner;
1258   group = jgroup;
1259   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1260   r = guestfs_chown (g, owner, group, path);
1261   (*env)->ReleaseStringUTFChars (env, jpath, path);
1262   if (r == -1) {
1263     throw_exception (env, guestfs_last_error (g));
1264     return ;
1265   }
1266 }
1267
1268 JNIEXPORT jboolean JNICALL
1269 Java_com_redhat_et_libguestfs__1exists
1270   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1271 {
1272   guestfs_h *g = (guestfs_h *) jg;
1273   int r;
1274   const char *path;
1275
1276   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1277   r = guestfs_exists (g, path);
1278   (*env)->ReleaseStringUTFChars (env, jpath, path);
1279   if (r == -1) {
1280     throw_exception (env, guestfs_last_error (g));
1281     return 0;
1282   }
1283   return (jboolean) r;
1284 }
1285
1286 JNIEXPORT jboolean JNICALL
1287 Java_com_redhat_et_libguestfs__1is_1file
1288   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1289 {
1290   guestfs_h *g = (guestfs_h *) jg;
1291   int r;
1292   const char *path;
1293
1294   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1295   r = guestfs_is_file (g, path);
1296   (*env)->ReleaseStringUTFChars (env, jpath, path);
1297   if (r == -1) {
1298     throw_exception (env, guestfs_last_error (g));
1299     return 0;
1300   }
1301   return (jboolean) r;
1302 }
1303
1304 JNIEXPORT jboolean JNICALL
1305 Java_com_redhat_et_libguestfs__1is_1dir
1306   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1307 {
1308   guestfs_h *g = (guestfs_h *) jg;
1309   int r;
1310   const char *path;
1311
1312   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1313   r = guestfs_is_dir (g, path);
1314   (*env)->ReleaseStringUTFChars (env, jpath, path);
1315   if (r == -1) {
1316     throw_exception (env, guestfs_last_error (g));
1317     return 0;
1318   }
1319   return (jboolean) r;
1320 }
1321
1322 JNIEXPORT void JNICALL
1323 Java_com_redhat_et_libguestfs__1pvcreate
1324   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1325 {
1326   guestfs_h *g = (guestfs_h *) jg;
1327   int r;
1328   const char *device;
1329
1330   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1331   r = guestfs_pvcreate (g, device);
1332   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1333   if (r == -1) {
1334     throw_exception (env, guestfs_last_error (g));
1335     return ;
1336   }
1337 }
1338
1339 JNIEXPORT void JNICALL
1340 Java_com_redhat_et_libguestfs__1vgcreate
1341   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
1342 {
1343   guestfs_h *g = (guestfs_h *) jg;
1344   int r;
1345   const char *volgroup;
1346   int physvols_len;
1347   const char **physvols;
1348   int i;
1349
1350   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
1351   physvols_len = (*env)->GetArrayLength (env, jphysvols);
1352   physvols = malloc (sizeof (char *) * (physvols_len+1));
1353   for (i = 0; i < physvols_len; ++i) {
1354     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
1355     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
1356   }
1357   physvols[physvols_len] = NULL;
1358   r = guestfs_vgcreate (g, volgroup, physvols);
1359   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
1360   for (i = 0; i < physvols_len; ++i) {
1361     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
1362     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
1363   }
1364   free (physvols);
1365   if (r == -1) {
1366     throw_exception (env, guestfs_last_error (g));
1367     return ;
1368   }
1369 }
1370
1371 JNIEXPORT void JNICALL
1372 Java_com_redhat_et_libguestfs__1lvcreate
1373   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
1374 {
1375   guestfs_h *g = (guestfs_h *) jg;
1376   int r;
1377   const char *logvol;
1378   const char *volgroup;
1379   int mbytes;
1380
1381   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
1382   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
1383   mbytes = jmbytes;
1384   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
1385   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
1386   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
1387   if (r == -1) {
1388     throw_exception (env, guestfs_last_error (g));
1389     return ;
1390   }
1391 }
1392
1393 JNIEXPORT void JNICALL
1394 Java_com_redhat_et_libguestfs__1mkfs
1395   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
1396 {
1397   guestfs_h *g = (guestfs_h *) jg;
1398   int r;
1399   const char *fstype;
1400   const char *device;
1401
1402   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
1403   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1404   r = guestfs_mkfs (g, fstype, device);
1405   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
1406   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1407   if (r == -1) {
1408     throw_exception (env, guestfs_last_error (g));
1409     return ;
1410   }
1411 }
1412
1413 JNIEXPORT void JNICALL
1414 Java_com_redhat_et_libguestfs__1sfdisk
1415   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
1416 {
1417   guestfs_h *g = (guestfs_h *) jg;
1418   int r;
1419   const char *device;
1420   int cyls;
1421   int heads;
1422   int sectors;
1423   int lines_len;
1424   const char **lines;
1425   int i;
1426
1427   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1428   cyls = jcyls;
1429   heads = jheads;
1430   sectors = jsectors;
1431   lines_len = (*env)->GetArrayLength (env, jlines);
1432   lines = malloc (sizeof (char *) * (lines_len+1));
1433   for (i = 0; i < lines_len; ++i) {
1434     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
1435     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
1436   }
1437   lines[lines_len] = NULL;
1438   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
1439   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1440   for (i = 0; i < lines_len; ++i) {
1441     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
1442     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
1443   }
1444   free (lines);
1445   if (r == -1) {
1446     throw_exception (env, guestfs_last_error (g));
1447     return ;
1448   }
1449 }
1450
1451 JNIEXPORT void JNICALL
1452 Java_com_redhat_et_libguestfs__1write_1file
1453   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
1454 {
1455   guestfs_h *g = (guestfs_h *) jg;
1456   int r;
1457   const char *path;
1458   const char *content;
1459   int size;
1460
1461   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1462   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
1463   size = jsize;
1464   r = guestfs_write_file (g, path, content, size);
1465   (*env)->ReleaseStringUTFChars (env, jpath, path);
1466   (*env)->ReleaseStringUTFChars (env, jcontent, content);
1467   if (r == -1) {
1468     throw_exception (env, guestfs_last_error (g));
1469     return ;
1470   }
1471 }
1472
1473 JNIEXPORT void JNICALL
1474 Java_com_redhat_et_libguestfs__1umount
1475   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
1476 {
1477   guestfs_h *g = (guestfs_h *) jg;
1478   int r;
1479   const char *pathordevice;
1480
1481   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
1482   r = guestfs_umount (g, pathordevice);
1483   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
1484   if (r == -1) {
1485     throw_exception (env, guestfs_last_error (g));
1486     return ;
1487   }
1488 }
1489
1490 JNIEXPORT jobjectArray JNICALL
1491 Java_com_redhat_et_libguestfs__1mounts
1492   (JNIEnv *env, jobject obj, jlong jg)
1493 {
1494   guestfs_h *g = (guestfs_h *) jg;
1495   jobjectArray jr;
1496   int r_len;
1497   jclass cl;
1498   jstring jstr;
1499   char **r;
1500   int i;
1501
1502   r = guestfs_mounts (g);
1503   if (r == NULL) {
1504     throw_exception (env, guestfs_last_error (g));
1505     return NULL;
1506   }
1507   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1508   cl = (*env)->FindClass (env, "java/lang/String");
1509   jstr = (*env)->NewStringUTF (env, "");
1510   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1511   for (i = 0; i < r_len; ++i) {
1512     jstr = (*env)->NewStringUTF (env, r[i]);
1513     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1514     free (r[i]);
1515   }
1516   free (r);
1517   return jr;
1518 }
1519
1520 JNIEXPORT void JNICALL
1521 Java_com_redhat_et_libguestfs__1umount_1all
1522   (JNIEnv *env, jobject obj, jlong jg)
1523 {
1524   guestfs_h *g = (guestfs_h *) jg;
1525   int r;
1526
1527   r = guestfs_umount_all (g);
1528   if (r == -1) {
1529     throw_exception (env, guestfs_last_error (g));
1530     return ;
1531   }
1532 }
1533
1534 JNIEXPORT void JNICALL
1535 Java_com_redhat_et_libguestfs__1lvm_1remove_1all
1536   (JNIEnv *env, jobject obj, jlong jg)
1537 {
1538   guestfs_h *g = (guestfs_h *) jg;
1539   int r;
1540
1541   r = guestfs_lvm_remove_all (g);
1542   if (r == -1) {
1543     throw_exception (env, guestfs_last_error (g));
1544     return ;
1545   }
1546 }
1547
1548 JNIEXPORT jstring JNICALL
1549 Java_com_redhat_et_libguestfs__1file
1550   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1551 {
1552   guestfs_h *g = (guestfs_h *) jg;
1553   jstring jr;
1554   char *r;
1555   const char *path;
1556
1557   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1558   r = guestfs_file (g, path);
1559   (*env)->ReleaseStringUTFChars (env, jpath, path);
1560   if (r == NULL) {
1561     throw_exception (env, guestfs_last_error (g));
1562     return NULL;
1563   }
1564   jr = (*env)->NewStringUTF (env, r);
1565   free (r);
1566   return jr;
1567 }
1568
1569 JNIEXPORT jstring JNICALL
1570 Java_com_redhat_et_libguestfs__1command
1571   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
1572 {
1573   guestfs_h *g = (guestfs_h *) jg;
1574   jstring jr;
1575   char *r;
1576   int arguments_len;
1577   const char **arguments;
1578   int i;
1579
1580   arguments_len = (*env)->GetArrayLength (env, jarguments);
1581   arguments = malloc (sizeof (char *) * (arguments_len+1));
1582   for (i = 0; i < arguments_len; ++i) {
1583     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1584     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
1585   }
1586   arguments[arguments_len] = NULL;
1587   r = guestfs_command (g, arguments);
1588   for (i = 0; i < arguments_len; ++i) {
1589     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1590     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
1591   }
1592   free (arguments);
1593   if (r == NULL) {
1594     throw_exception (env, guestfs_last_error (g));
1595     return NULL;
1596   }
1597   jr = (*env)->NewStringUTF (env, r);
1598   free (r);
1599   return jr;
1600 }
1601
1602 JNIEXPORT jobjectArray JNICALL
1603 Java_com_redhat_et_libguestfs__1command_1lines
1604   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
1605 {
1606   guestfs_h *g = (guestfs_h *) jg;
1607   jobjectArray jr;
1608   int r_len;
1609   jclass cl;
1610   jstring jstr;
1611   char **r;
1612   int arguments_len;
1613   const char **arguments;
1614   int i;
1615
1616   arguments_len = (*env)->GetArrayLength (env, jarguments);
1617   arguments = malloc (sizeof (char *) * (arguments_len+1));
1618   for (i = 0; i < arguments_len; ++i) {
1619     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1620     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
1621   }
1622   arguments[arguments_len] = NULL;
1623   r = guestfs_command_lines (g, arguments);
1624   for (i = 0; i < arguments_len; ++i) {
1625     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
1626     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
1627   }
1628   free (arguments);
1629   if (r == NULL) {
1630     throw_exception (env, guestfs_last_error (g));
1631     return NULL;
1632   }
1633   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1634   cl = (*env)->FindClass (env, "java/lang/String");
1635   jstr = (*env)->NewStringUTF (env, "");
1636   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1637   for (i = 0; i < r_len; ++i) {
1638     jstr = (*env)->NewStringUTF (env, r[i]);
1639     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1640     free (r[i]);
1641   }
1642   free (r);
1643   return jr;
1644 }
1645
1646 JNIEXPORT jobject JNICALL
1647 Java_com_redhat_et_libguestfs__1stat
1648   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1649 {
1650   guestfs_h *g = (guestfs_h *) jg;
1651   jobject jr;
1652   jclass cl;
1653   jfieldID fl;
1654   struct guestfs_stat *r;
1655   const char *path;
1656
1657   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1658   r = guestfs_stat (g, path);
1659   (*env)->ReleaseStringUTFChars (env, jpath, path);
1660   if (r == NULL) {
1661     throw_exception (env, guestfs_last_error (g));
1662     return NULL;
1663   }
1664   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
1665   jr = (*env)->AllocObject (env, cl);
1666   fl = (*env)->GetFieldID (env, cl, "dev", "J");
1667   (*env)->SetLongField (env, jr, fl, r->dev);
1668   fl = (*env)->GetFieldID (env, cl, "ino", "J");
1669   (*env)->SetLongField (env, jr, fl, r->ino);
1670   fl = (*env)->GetFieldID (env, cl, "mode", "J");
1671   (*env)->SetLongField (env, jr, fl, r->mode);
1672   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
1673   (*env)->SetLongField (env, jr, fl, r->nlink);
1674   fl = (*env)->GetFieldID (env, cl, "uid", "J");
1675   (*env)->SetLongField (env, jr, fl, r->uid);
1676   fl = (*env)->GetFieldID (env, cl, "gid", "J");
1677   (*env)->SetLongField (env, jr, fl, r->gid);
1678   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
1679   (*env)->SetLongField (env, jr, fl, r->rdev);
1680   fl = (*env)->GetFieldID (env, cl, "size", "J");
1681   (*env)->SetLongField (env, jr, fl, r->size);
1682   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
1683   (*env)->SetLongField (env, jr, fl, r->blksize);
1684   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1685   (*env)->SetLongField (env, jr, fl, r->blocks);
1686   fl = (*env)->GetFieldID (env, cl, "atime", "J");
1687   (*env)->SetLongField (env, jr, fl, r->atime);
1688   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
1689   (*env)->SetLongField (env, jr, fl, r->mtime);
1690   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
1691   (*env)->SetLongField (env, jr, fl, r->ctime);
1692   free (r);
1693   return jr;
1694 }
1695
1696 JNIEXPORT jobject JNICALL
1697 Java_com_redhat_et_libguestfs__1lstat
1698   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1699 {
1700   guestfs_h *g = (guestfs_h *) jg;
1701   jobject jr;
1702   jclass cl;
1703   jfieldID fl;
1704   struct guestfs_stat *r;
1705   const char *path;
1706
1707   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1708   r = guestfs_lstat (g, path);
1709   (*env)->ReleaseStringUTFChars (env, jpath, path);
1710   if (r == NULL) {
1711     throw_exception (env, guestfs_last_error (g));
1712     return NULL;
1713   }
1714   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
1715   jr = (*env)->AllocObject (env, cl);
1716   fl = (*env)->GetFieldID (env, cl, "dev", "J");
1717   (*env)->SetLongField (env, jr, fl, r->dev);
1718   fl = (*env)->GetFieldID (env, cl, "ino", "J");
1719   (*env)->SetLongField (env, jr, fl, r->ino);
1720   fl = (*env)->GetFieldID (env, cl, "mode", "J");
1721   (*env)->SetLongField (env, jr, fl, r->mode);
1722   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
1723   (*env)->SetLongField (env, jr, fl, r->nlink);
1724   fl = (*env)->GetFieldID (env, cl, "uid", "J");
1725   (*env)->SetLongField (env, jr, fl, r->uid);
1726   fl = (*env)->GetFieldID (env, cl, "gid", "J");
1727   (*env)->SetLongField (env, jr, fl, r->gid);
1728   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
1729   (*env)->SetLongField (env, jr, fl, r->rdev);
1730   fl = (*env)->GetFieldID (env, cl, "size", "J");
1731   (*env)->SetLongField (env, jr, fl, r->size);
1732   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
1733   (*env)->SetLongField (env, jr, fl, r->blksize);
1734   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1735   (*env)->SetLongField (env, jr, fl, r->blocks);
1736   fl = (*env)->GetFieldID (env, cl, "atime", "J");
1737   (*env)->SetLongField (env, jr, fl, r->atime);
1738   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
1739   (*env)->SetLongField (env, jr, fl, r->mtime);
1740   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
1741   (*env)->SetLongField (env, jr, fl, r->ctime);
1742   free (r);
1743   return jr;
1744 }
1745
1746 JNIEXPORT jobject JNICALL
1747 Java_com_redhat_et_libguestfs__1statvfs
1748   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1749 {
1750   guestfs_h *g = (guestfs_h *) jg;
1751   jobject jr;
1752   jclass cl;
1753   jfieldID fl;
1754   struct guestfs_statvfs *r;
1755   const char *path;
1756
1757   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1758   r = guestfs_statvfs (g, path);
1759   (*env)->ReleaseStringUTFChars (env, jpath, path);
1760   if (r == NULL) {
1761     throw_exception (env, guestfs_last_error (g));
1762     return NULL;
1763   }
1764   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
1765   jr = (*env)->AllocObject (env, cl);
1766   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
1767   (*env)->SetLongField (env, jr, fl, r->bsize);
1768   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
1769   (*env)->SetLongField (env, jr, fl, r->frsize);
1770   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
1771   (*env)->SetLongField (env, jr, fl, r->blocks);
1772   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
1773   (*env)->SetLongField (env, jr, fl, r->bfree);
1774   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
1775   (*env)->SetLongField (env, jr, fl, r->bavail);
1776   fl = (*env)->GetFieldID (env, cl, "files", "J");
1777   (*env)->SetLongField (env, jr, fl, r->files);
1778   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
1779   (*env)->SetLongField (env, jr, fl, r->ffree);
1780   fl = (*env)->GetFieldID (env, cl, "favail", "J");
1781   (*env)->SetLongField (env, jr, fl, r->favail);
1782   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
1783   (*env)->SetLongField (env, jr, fl, r->fsid);
1784   fl = (*env)->GetFieldID (env, cl, "flag", "J");
1785   (*env)->SetLongField (env, jr, fl, r->flag);
1786   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
1787   (*env)->SetLongField (env, jr, fl, r->namemax);
1788   free (r);
1789   return jr;
1790 }
1791
1792 JNIEXPORT jobject JNICALL
1793 Java_com_redhat_et_libguestfs__1tune2fs_1l
1794   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1795 {
1796   guestfs_h *g = (guestfs_h *) jg;
1797   char **r;
1798   const char *device;
1799
1800   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1801   r = guestfs_tune2fs_l (g, device);
1802   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1803   if (r == NULL) {
1804     throw_exception (env, guestfs_last_error (g));
1805     return NULL;
1806   }
1807   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1808   return NULL;
1809 }
1810
1811 JNIEXPORT void JNICALL
1812 Java_com_redhat_et_libguestfs__1blockdev_1setro
1813   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1814 {
1815   guestfs_h *g = (guestfs_h *) jg;
1816   int r;
1817   const char *device;
1818
1819   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1820   r = guestfs_blockdev_setro (g, device);
1821   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1822   if (r == -1) {
1823     throw_exception (env, guestfs_last_error (g));
1824     return ;
1825   }
1826 }
1827
1828 JNIEXPORT void JNICALL
1829 Java_com_redhat_et_libguestfs__1blockdev_1setrw
1830   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1831 {
1832   guestfs_h *g = (guestfs_h *) jg;
1833   int r;
1834   const char *device;
1835
1836   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1837   r = guestfs_blockdev_setrw (g, device);
1838   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1839   if (r == -1) {
1840     throw_exception (env, guestfs_last_error (g));
1841     return ;
1842   }
1843 }
1844
1845 JNIEXPORT jboolean JNICALL
1846 Java_com_redhat_et_libguestfs__1blockdev_1getro
1847   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1848 {
1849   guestfs_h *g = (guestfs_h *) jg;
1850   int r;
1851   const char *device;
1852
1853   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1854   r = guestfs_blockdev_getro (g, device);
1855   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1856   if (r == -1) {
1857     throw_exception (env, guestfs_last_error (g));
1858     return 0;
1859   }
1860   return (jboolean) r;
1861 }
1862
1863 JNIEXPORT jint JNICALL
1864 Java_com_redhat_et_libguestfs__1blockdev_1getss
1865   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1866 {
1867   guestfs_h *g = (guestfs_h *) jg;
1868   int r;
1869   const char *device;
1870
1871   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1872   r = guestfs_blockdev_getss (g, device);
1873   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1874   if (r == -1) {
1875     throw_exception (env, guestfs_last_error (g));
1876     return 0;
1877   }
1878   return (jint) r;
1879 }
1880
1881 JNIEXPORT jint JNICALL
1882 Java_com_redhat_et_libguestfs__1blockdev_1getbsz
1883   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1884 {
1885   guestfs_h *g = (guestfs_h *) jg;
1886   int r;
1887   const char *device;
1888
1889   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1890   r = guestfs_blockdev_getbsz (g, device);
1891   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1892   if (r == -1) {
1893     throw_exception (env, guestfs_last_error (g));
1894     return 0;
1895   }
1896   return (jint) r;
1897 }
1898
1899 JNIEXPORT void JNICALL
1900 Java_com_redhat_et_libguestfs__1blockdev_1setbsz
1901   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
1902 {
1903   guestfs_h *g = (guestfs_h *) jg;
1904   int r;
1905   const char *device;
1906   int blocksize;
1907
1908   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1909   blocksize = jblocksize;
1910   r = guestfs_blockdev_setbsz (g, device, blocksize);
1911   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1912   if (r == -1) {
1913     throw_exception (env, guestfs_last_error (g));
1914     return ;
1915   }
1916 }
1917
1918 JNIEXPORT jlong JNICALL
1919 Java_com_redhat_et_libguestfs__1blockdev_1getsz
1920   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1921 {
1922   guestfs_h *g = (guestfs_h *) jg;
1923   int64_t r;
1924   const char *device;
1925
1926   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1927   r = guestfs_blockdev_getsz (g, device);
1928   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1929   if (r == -1) {
1930     throw_exception (env, guestfs_last_error (g));
1931     return 0;
1932   }
1933   return (jlong) r;
1934 }
1935
1936 JNIEXPORT jlong JNICALL
1937 Java_com_redhat_et_libguestfs__1blockdev_1getsize64
1938   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1939 {
1940   guestfs_h *g = (guestfs_h *) jg;
1941   int64_t r;
1942   const char *device;
1943
1944   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1945   r = guestfs_blockdev_getsize64 (g, device);
1946   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1947   if (r == -1) {
1948     throw_exception (env, guestfs_last_error (g));
1949     return 0;
1950   }
1951   return (jlong) r;
1952 }
1953
1954 JNIEXPORT void JNICALL
1955 Java_com_redhat_et_libguestfs__1blockdev_1flushbufs
1956   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1957 {
1958   guestfs_h *g = (guestfs_h *) jg;
1959   int r;
1960   const char *device;
1961
1962   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1963   r = guestfs_blockdev_flushbufs (g, device);
1964   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1965   if (r == -1) {
1966     throw_exception (env, guestfs_last_error (g));
1967     return ;
1968   }
1969 }
1970
1971 JNIEXPORT void JNICALL
1972 Java_com_redhat_et_libguestfs__1blockdev_1rereadpt
1973   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
1974 {
1975   guestfs_h *g = (guestfs_h *) jg;
1976   int r;
1977   const char *device;
1978
1979   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1980   r = guestfs_blockdev_rereadpt (g, device);
1981   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1982   if (r == -1) {
1983     throw_exception (env, guestfs_last_error (g));
1984     return ;
1985   }
1986 }
1987
1988 JNIEXPORT void JNICALL
1989 Java_com_redhat_et_libguestfs__1upload
1990   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
1991 {
1992   guestfs_h *g = (guestfs_h *) jg;
1993   int r;
1994   const char *filename;
1995   const char *remotefilename;
1996
1997   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1998   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
1999   r = guestfs_upload (g, filename, remotefilename);
2000   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
2001   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
2002   if (r == -1) {
2003     throw_exception (env, guestfs_last_error (g));
2004     return ;
2005   }
2006 }
2007
2008 JNIEXPORT void JNICALL
2009 Java_com_redhat_et_libguestfs__1download
2010   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
2011 {
2012   guestfs_h *g = (guestfs_h *) jg;
2013   int r;
2014   const char *remotefilename;
2015   const char *filename;
2016
2017   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
2018   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
2019   r = guestfs_download (g, remotefilename, filename);
2020   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
2021   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
2022   if (r == -1) {
2023     throw_exception (env, guestfs_last_error (g));
2024     return ;
2025   }
2026 }
2027
2028 JNIEXPORT jstring JNICALL
2029 Java_com_redhat_et_libguestfs__1checksum
2030   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
2031 {
2032   guestfs_h *g = (guestfs_h *) jg;
2033   jstring jr;
2034   char *r;
2035   const char *csumtype;
2036   const char *path;
2037
2038   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
2039   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2040   r = guestfs_checksum (g, csumtype, path);
2041   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
2042   (*env)->ReleaseStringUTFChars (env, jpath, path);
2043   if (r == NULL) {
2044     throw_exception (env, guestfs_last_error (g));
2045     return NULL;
2046   }
2047   jr = (*env)->NewStringUTF (env, r);
2048   free (r);
2049   return jr;
2050 }
2051
2052 JNIEXPORT void JNICALL
2053 Java_com_redhat_et_libguestfs__1tar_1in
2054   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
2055 {
2056   guestfs_h *g = (guestfs_h *) jg;
2057   int r;
2058   const char *tarfile;
2059   const char *directory;
2060
2061   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
2062   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2063   r = guestfs_tar_in (g, tarfile, directory);
2064   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
2065   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2066   if (r == -1) {
2067     throw_exception (env, guestfs_last_error (g));
2068     return ;
2069   }
2070 }
2071
2072 JNIEXPORT void JNICALL
2073 Java_com_redhat_et_libguestfs__1tar_1out
2074   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
2075 {
2076   guestfs_h *g = (guestfs_h *) jg;
2077   int r;
2078   const char *directory;
2079   const char *tarfile;
2080
2081   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2082   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
2083   r = guestfs_tar_out (g, directory, tarfile);
2084   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2085   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
2086   if (r == -1) {
2087     throw_exception (env, guestfs_last_error (g));
2088     return ;
2089   }
2090 }
2091
2092 JNIEXPORT void JNICALL
2093 Java_com_redhat_et_libguestfs__1tgz_1in
2094   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
2095 {
2096   guestfs_h *g = (guestfs_h *) jg;
2097   int r;
2098   const char *tarball;
2099   const char *directory;
2100
2101   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
2102   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2103   r = guestfs_tgz_in (g, tarball, directory);
2104   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
2105   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2106   if (r == -1) {
2107     throw_exception (env, guestfs_last_error (g));
2108     return ;
2109   }
2110 }
2111
2112 JNIEXPORT void JNICALL
2113 Java_com_redhat_et_libguestfs__1tgz_1out
2114   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
2115 {
2116   guestfs_h *g = (guestfs_h *) jg;
2117   int r;
2118   const char *directory;
2119   const char *tarball;
2120
2121   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
2122   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
2123   r = guestfs_tgz_out (g, directory, tarball);
2124   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
2125   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
2126   if (r == -1) {
2127     throw_exception (env, guestfs_last_error (g));
2128     return ;
2129   }
2130 }
2131