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