df1610252a9412de4a09f187fd1db90a267b9d5e
[libguestfs.git] / java / com_redhat_et_libguestfs_GuestFS.c
1 /* libguestfs generated file
2  * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3  * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
4  *
5  * Copyright (C) 2009 Red Hat Inc.
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25
26 #include "com_redhat_et_libguestfs_GuestFS.h"
27 #include "guestfs.h"
28
29 /* Note that this function returns.  The exception is not thrown
30  * until after the wrapper function returns.
31  */
32 static void
33 throw_exception (JNIEnv *env, const char *msg)
34 {
35   jclass cl;
36   cl = (*env)->FindClass (env,
37                           "com/redhat/et/libguestfs/LibGuestFSException");
38   (*env)->ThrowNew (env, cl, msg);
39 }
40
41 JNIEXPORT jlong JNICALL
42 Java_com_redhat_et_libguestfs_GuestFS__1create
43   (JNIEnv *env, jobject obj)
44 {
45   guestfs_h *g;
46
47   g = guestfs_create ();
48   if (g == NULL) {
49     throw_exception (env, "GuestFS.create: failed to allocate handle");
50     return 0;
51   }
52   guestfs_set_error_handler (g, NULL, NULL);
53   return (jlong) (long) g;
54 }
55
56 JNIEXPORT void JNICALL
57 Java_com_redhat_et_libguestfs_GuestFS__1close
58   (JNIEnv *env, jobject obj, jlong jg)
59 {
60   guestfs_h *g = (guestfs_h *) (long) jg;
61   guestfs_close (g);
62 }
63
64 JNIEXPORT void JNICALL
65 Java_com_redhat_et_libguestfs_GuestFS__1test0
66   (JNIEnv *env, jobject obj, jlong jg, jstring jstr, jstring joptstr, jobjectArray jstrlist, jboolean jb, jint jinteger, jstring jfilein, jstring jfileout)
67 {
68   guestfs_h *g = (guestfs_h *) (long) jg;
69   int r;
70   const char *str;
71   const char *optstr;
72   int strlist_len;
73   const char **strlist;
74   int b;
75   int integer;
76   const char *filein;
77   const char *fileout;
78   int i;
79
80   str = (*env)->GetStringUTFChars (env, jstr, NULL);
81   optstr = joptstr ? (*env)->GetStringUTFChars (env, joptstr, NULL) : NULL;
82   strlist_len = (*env)->GetArrayLength (env, jstrlist);
83   strlist = guestfs_safe_malloc (g, sizeof (char *) * (strlist_len+1));
84   for (i = 0; i < strlist_len; ++i) {
85     jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
86     strlist[i] = (*env)->GetStringUTFChars (env, o, NULL);
87   }
88   strlist[strlist_len] = NULL;
89   b = jb;
90   integer = jinteger;
91   filein = (*env)->GetStringUTFChars (env, jfilein, NULL);
92   fileout = (*env)->GetStringUTFChars (env, jfileout, NULL);
93   r = guestfs_test0 (g, str, optstr, strlist, b, integer, filein, fileout);
94   (*env)->ReleaseStringUTFChars (env, jstr, str);
95   if (joptstr)
96     (*env)->ReleaseStringUTFChars (env, joptstr, optstr);
97   for (i = 0; i < strlist_len; ++i) {
98     jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
99     (*env)->ReleaseStringUTFChars (env, o, strlist[i]);
100   }
101   free (strlist);
102   (*env)->ReleaseStringUTFChars (env, jfilein, filein);
103   (*env)->ReleaseStringUTFChars (env, jfileout, fileout);
104   if (r == -1) {
105     throw_exception (env, guestfs_last_error (g));
106     return ;
107   }
108 }
109
110 JNIEXPORT jint JNICALL
111 Java_com_redhat_et_libguestfs_GuestFS__1test0rint
112   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
113 {
114   guestfs_h *g = (guestfs_h *) (long) jg;
115   int r;
116   const char *val;
117
118   val = (*env)->GetStringUTFChars (env, jval, NULL);
119   r = guestfs_test0rint (g, val);
120   (*env)->ReleaseStringUTFChars (env, jval, val);
121   if (r == -1) {
122     throw_exception (env, guestfs_last_error (g));
123     return 0;
124   }
125   return (jint) r;
126 }
127
128 JNIEXPORT jint JNICALL
129 Java_com_redhat_et_libguestfs_GuestFS__1test0rinterr
130   (JNIEnv *env, jobject obj, jlong jg)
131 {
132   guestfs_h *g = (guestfs_h *) (long) jg;
133   int r;
134
135   r = guestfs_test0rinterr (g);
136   if (r == -1) {
137     throw_exception (env, guestfs_last_error (g));
138     return 0;
139   }
140   return (jint) r;
141 }
142
143 JNIEXPORT jlong JNICALL
144 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64
145   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
146 {
147   guestfs_h *g = (guestfs_h *) (long) jg;
148   int64_t r;
149   const char *val;
150
151   val = (*env)->GetStringUTFChars (env, jval, NULL);
152   r = guestfs_test0rint64 (g, val);
153   (*env)->ReleaseStringUTFChars (env, jval, val);
154   if (r == -1) {
155     throw_exception (env, guestfs_last_error (g));
156     return 0;
157   }
158   return (jlong) r;
159 }
160
161 JNIEXPORT jlong JNICALL
162 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64err
163   (JNIEnv *env, jobject obj, jlong jg)
164 {
165   guestfs_h *g = (guestfs_h *) (long) jg;
166   int64_t r;
167
168   r = guestfs_test0rint64err (g);
169   if (r == -1) {
170     throw_exception (env, guestfs_last_error (g));
171     return 0;
172   }
173   return (jlong) r;
174 }
175
176 JNIEXPORT jboolean JNICALL
177 Java_com_redhat_et_libguestfs_GuestFS__1test0rbool
178   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
179 {
180   guestfs_h *g = (guestfs_h *) (long) jg;
181   int r;
182   const char *val;
183
184   val = (*env)->GetStringUTFChars (env, jval, NULL);
185   r = guestfs_test0rbool (g, val);
186   (*env)->ReleaseStringUTFChars (env, jval, val);
187   if (r == -1) {
188     throw_exception (env, guestfs_last_error (g));
189     return 0;
190   }
191   return (jboolean) r;
192 }
193
194 JNIEXPORT jboolean JNICALL
195 Java_com_redhat_et_libguestfs_GuestFS__1test0rboolerr
196   (JNIEnv *env, jobject obj, jlong jg)
197 {
198   guestfs_h *g = (guestfs_h *) (long) jg;
199   int r;
200
201   r = guestfs_test0rboolerr (g);
202   if (r == -1) {
203     throw_exception (env, guestfs_last_error (g));
204     return 0;
205   }
206   return (jboolean) r;
207 }
208
209 JNIEXPORT jstring JNICALL
210 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststring
211   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
212 {
213   guestfs_h *g = (guestfs_h *) (long) jg;
214   const char *r;
215   const char *val;
216
217   val = (*env)->GetStringUTFChars (env, jval, NULL);
218   r = guestfs_test0rconststring (g, val);
219   (*env)->ReleaseStringUTFChars (env, jval, val);
220   if (r == NULL) {
221     throw_exception (env, guestfs_last_error (g));
222     return NULL;
223   }
224   return (*env)->NewStringUTF (env, r);
225 }
226
227 JNIEXPORT jstring JNICALL
228 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststringerr
229   (JNIEnv *env, jobject obj, jlong jg)
230 {
231   guestfs_h *g = (guestfs_h *) (long) jg;
232   const char *r;
233
234   r = guestfs_test0rconststringerr (g);
235   if (r == NULL) {
236     throw_exception (env, guestfs_last_error (g));
237     return NULL;
238   }
239   return (*env)->NewStringUTF (env, r);
240 }
241
242 JNIEXPORT jstring JNICALL
243 Java_com_redhat_et_libguestfs_GuestFS__1test0rstring
244   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
245 {
246   guestfs_h *g = (guestfs_h *) (long) jg;
247   jstring jr;
248   char *r;
249   const char *val;
250
251   val = (*env)->GetStringUTFChars (env, jval, NULL);
252   r = guestfs_test0rstring (g, val);
253   (*env)->ReleaseStringUTFChars (env, jval, val);
254   if (r == NULL) {
255     throw_exception (env, guestfs_last_error (g));
256     return NULL;
257   }
258   jr = (*env)->NewStringUTF (env, r);
259   free (r);
260   return jr;
261 }
262
263 JNIEXPORT jstring JNICALL
264 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringerr
265   (JNIEnv *env, jobject obj, jlong jg)
266 {
267   guestfs_h *g = (guestfs_h *) (long) jg;
268   jstring jr;
269   char *r;
270
271   r = guestfs_test0rstringerr (g);
272   if (r == NULL) {
273     throw_exception (env, guestfs_last_error (g));
274     return NULL;
275   }
276   jr = (*env)->NewStringUTF (env, r);
277   free (r);
278   return jr;
279 }
280
281 JNIEXPORT jobjectArray JNICALL
282 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlist
283   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
284 {
285   guestfs_h *g = (guestfs_h *) (long) jg;
286   jobjectArray jr;
287   int r_len;
288   jclass cl;
289   jstring jstr;
290   char **r;
291   const char *val;
292   int i;
293
294   val = (*env)->GetStringUTFChars (env, jval, NULL);
295   r = guestfs_test0rstringlist (g, val);
296   (*env)->ReleaseStringUTFChars (env, jval, val);
297   if (r == NULL) {
298     throw_exception (env, guestfs_last_error (g));
299     return NULL;
300   }
301   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
302   cl = (*env)->FindClass (env, "java/lang/String");
303   jstr = (*env)->NewStringUTF (env, "");
304   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
305   for (i = 0; i < r_len; ++i) {
306     jstr = (*env)->NewStringUTF (env, r[i]);
307     (*env)->SetObjectArrayElement (env, jr, i, jstr);
308     free (r[i]);
309   }
310   free (r);
311   return jr;
312 }
313
314 JNIEXPORT jobjectArray JNICALL
315 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlisterr
316   (JNIEnv *env, jobject obj, jlong jg)
317 {
318   guestfs_h *g = (guestfs_h *) (long) jg;
319   jobjectArray jr;
320   int r_len;
321   jclass cl;
322   jstring jstr;
323   char **r;
324   int i;
325
326   r = guestfs_test0rstringlisterr (g);
327   if (r == NULL) {
328     throw_exception (env, guestfs_last_error (g));
329     return NULL;
330   }
331   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
332   cl = (*env)->FindClass (env, "java/lang/String");
333   jstr = (*env)->NewStringUTF (env, "");
334   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
335   for (i = 0; i < r_len; ++i) {
336     jstr = (*env)->NewStringUTF (env, r[i]);
337     (*env)->SetObjectArrayElement (env, jr, i, jstr);
338     free (r[i]);
339   }
340   free (r);
341   return jr;
342 }
343
344 JNIEXPORT jobject JNICALL
345 Java_com_redhat_et_libguestfs_GuestFS__1test0rintbool
346   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
347 {
348   guestfs_h *g = (guestfs_h *) (long) jg;
349   jobject jr;
350   jclass cl;
351   jfieldID fl;
352   struct guestfs_int_bool *r;
353   const char *val;
354
355   val = (*env)->GetStringUTFChars (env, jval, NULL);
356   r = guestfs_test0rintbool (g, val);
357   (*env)->ReleaseStringUTFChars (env, jval, val);
358   if (r == NULL) {
359     throw_exception (env, guestfs_last_error (g));
360     return NULL;
361   }
362   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
363   jr = (*env)->AllocObject (env, cl);
364   fl = (*env)->GetFieldID (env, cl, "i", "I");
365   (*env)->SetIntField (env, jr, fl, r->i);
366   fl = (*env)->GetFieldID (env, cl, "i", "Z");
367   (*env)->SetBooleanField (env, jr, fl, r->b);
368   guestfs_free_int_bool (r);
369   return jr;
370 }
371
372 JNIEXPORT jobject JNICALL
373 Java_com_redhat_et_libguestfs_GuestFS__1test0rintboolerr
374   (JNIEnv *env, jobject obj, jlong jg)
375 {
376   guestfs_h *g = (guestfs_h *) (long) jg;
377   jobject jr;
378   jclass cl;
379   jfieldID fl;
380   struct guestfs_int_bool *r;
381
382   r = guestfs_test0rintboolerr (g);
383   if (r == NULL) {
384     throw_exception (env, guestfs_last_error (g));
385     return NULL;
386   }
387   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
388   jr = (*env)->AllocObject (env, cl);
389   fl = (*env)->GetFieldID (env, cl, "i", "I");
390   (*env)->SetIntField (env, jr, fl, r->i);
391   fl = (*env)->GetFieldID (env, cl, "i", "Z");
392   (*env)->SetBooleanField (env, jr, fl, r->b);
393   guestfs_free_int_bool (r);
394   return jr;
395 }
396
397 JNIEXPORT jobjectArray JNICALL
398 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlist
399   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
400 {
401   guestfs_h *g = (guestfs_h *) (long) jg;
402   jobjectArray jr;
403   jclass cl;
404   jfieldID fl;
405   jobject jfl;
406   struct guestfs_lvm_pv_list *r;
407   const char *val;
408   int i;
409
410   val = (*env)->GetStringUTFChars (env, jval, NULL);
411   r = guestfs_test0rpvlist (g, val);
412   (*env)->ReleaseStringUTFChars (env, jval, val);
413   if (r == NULL) {
414     throw_exception (env, guestfs_last_error (g));
415     return NULL;
416   }
417   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
418   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
419   for (i = 0; i < r->len; ++i) {
420     jfl = (*env)->AllocObject (env, cl);
421     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
422     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
423     {
424       char s[33];
425       memcpy (s, r->val[i].pv_uuid, 32);
426       s[32] = 0;
427       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
428       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
429     }
430     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
431     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
432     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
433     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
434     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
435     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
436     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
437     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
438     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
439     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
440     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
441     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
442     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
443     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
444     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
445     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
446     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
447     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
448     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
449     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
450     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
451     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
452     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
453     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
454     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
455   }
456   guestfs_free_lvm_pv_list (r);
457   return jr;
458 }
459
460 JNIEXPORT jobjectArray JNICALL
461 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlisterr
462   (JNIEnv *env, jobject obj, jlong jg)
463 {
464   guestfs_h *g = (guestfs_h *) (long) jg;
465   jobjectArray jr;
466   jclass cl;
467   jfieldID fl;
468   jobject jfl;
469   struct guestfs_lvm_pv_list *r;
470   int i;
471
472   r = guestfs_test0rpvlisterr (g);
473   if (r == NULL) {
474     throw_exception (env, guestfs_last_error (g));
475     return NULL;
476   }
477   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
478   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
479   for (i = 0; i < r->len; ++i) {
480     jfl = (*env)->AllocObject (env, cl);
481     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
482     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
483     {
484       char s[33];
485       memcpy (s, r->val[i].pv_uuid, 32);
486       s[32] = 0;
487       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
488       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
489     }
490     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
491     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
492     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
493     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
494     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
495     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
496     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
497     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
498     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
499     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
500     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
501     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
502     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
503     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
504     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
505     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
506     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
507     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
508     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
509     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
510     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
511     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
512     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
513     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
514     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
515   }
516   guestfs_free_lvm_pv_list (r);
517   return jr;
518 }
519
520 JNIEXPORT jobjectArray JNICALL
521 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglist
522   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
523 {
524   guestfs_h *g = (guestfs_h *) (long) jg;
525   jobjectArray jr;
526   jclass cl;
527   jfieldID fl;
528   jobject jfl;
529   struct guestfs_lvm_vg_list *r;
530   const char *val;
531   int i;
532
533   val = (*env)->GetStringUTFChars (env, jval, NULL);
534   r = guestfs_test0rvglist (g, val);
535   (*env)->ReleaseStringUTFChars (env, jval, val);
536   if (r == NULL) {
537     throw_exception (env, guestfs_last_error (g));
538     return NULL;
539   }
540   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
541   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
542   for (i = 0; i < r->len; ++i) {
543     jfl = (*env)->AllocObject (env, cl);
544     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
545     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
546     {
547       char s[33];
548       memcpy (s, r->val[i].vg_uuid, 32);
549       s[32] = 0;
550       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
551       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
552     }
553     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
554     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
555     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
556     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
557     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
558     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
559     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
560     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
561     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
562     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
563     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
564     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
565     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
566     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
567     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
568     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
569     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
570     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
571     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
572     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
573     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
574     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
575     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
576     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
577     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
578     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
579     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
580     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
581     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
582     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
583     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
584     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
585     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
586     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
587     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
588   }
589   guestfs_free_lvm_vg_list (r);
590   return jr;
591 }
592
593 JNIEXPORT jobjectArray JNICALL
594 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglisterr
595   (JNIEnv *env, jobject obj, jlong jg)
596 {
597   guestfs_h *g = (guestfs_h *) (long) jg;
598   jobjectArray jr;
599   jclass cl;
600   jfieldID fl;
601   jobject jfl;
602   struct guestfs_lvm_vg_list *r;
603   int i;
604
605   r = guestfs_test0rvglisterr (g);
606   if (r == NULL) {
607     throw_exception (env, guestfs_last_error (g));
608     return NULL;
609   }
610   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
611   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
612   for (i = 0; i < r->len; ++i) {
613     jfl = (*env)->AllocObject (env, cl);
614     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
615     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
616     {
617       char s[33];
618       memcpy (s, r->val[i].vg_uuid, 32);
619       s[32] = 0;
620       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
621       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
622     }
623     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
624     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
625     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
626     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
627     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
628     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
629     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
630     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
631     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
632     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
633     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
634     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
635     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
636     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
637     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
638     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
639     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
640     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
641     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
642     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
643     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
644     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
645     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
646     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
647     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
648     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
649     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
650     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
651     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
652     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
653     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
654     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
655     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
656     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
657     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
658   }
659   guestfs_free_lvm_vg_list (r);
660   return jr;
661 }
662
663 JNIEXPORT jobjectArray JNICALL
664 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlist
665   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
666 {
667   guestfs_h *g = (guestfs_h *) (long) jg;
668   jobjectArray jr;
669   jclass cl;
670   jfieldID fl;
671   jobject jfl;
672   struct guestfs_lvm_lv_list *r;
673   const char *val;
674   int i;
675
676   val = (*env)->GetStringUTFChars (env, jval, NULL);
677   r = guestfs_test0rlvlist (g, val);
678   (*env)->ReleaseStringUTFChars (env, jval, val);
679   if (r == NULL) {
680     throw_exception (env, guestfs_last_error (g));
681     return NULL;
682   }
683   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
684   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
685   for (i = 0; i < r->len; ++i) {
686     jfl = (*env)->AllocObject (env, cl);
687     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
688     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
689     {
690       char s[33];
691       memcpy (s, r->val[i].lv_uuid, 32);
692       s[32] = 0;
693       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
694       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
695     }
696     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
697     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
698     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
699     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
700     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
701     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
702     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
703     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
704     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
705     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
706     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
707     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
708     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
709     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
710     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
711     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
712     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
713     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
714     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
715     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
716     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
717     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
718     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
719     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
720     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
721     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
722     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
723     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
724     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
725   }
726   guestfs_free_lvm_lv_list (r);
727   return jr;
728 }
729
730 JNIEXPORT jobjectArray JNICALL
731 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlisterr
732   (JNIEnv *env, jobject obj, jlong jg)
733 {
734   guestfs_h *g = (guestfs_h *) (long) jg;
735   jobjectArray jr;
736   jclass cl;
737   jfieldID fl;
738   jobject jfl;
739   struct guestfs_lvm_lv_list *r;
740   int i;
741
742   r = guestfs_test0rlvlisterr (g);
743   if (r == NULL) {
744     throw_exception (env, guestfs_last_error (g));
745     return NULL;
746   }
747   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
748   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
749   for (i = 0; i < r->len; ++i) {
750     jfl = (*env)->AllocObject (env, cl);
751     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
753     {
754       char s[33];
755       memcpy (s, r->val[i].lv_uuid, 32);
756       s[32] = 0;
757       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
758       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
759     }
760     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
761     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
762     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
763     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
764     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
765     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
766     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
767     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
768     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
769     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
770     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
771     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
772     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
773     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
774     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
775     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
776     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
777     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
778     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
779     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
780     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
781     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
782     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
783     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
784     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
785     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
786     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
787     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
788     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
789   }
790   guestfs_free_lvm_lv_list (r);
791   return jr;
792 }
793
794 JNIEXPORT jobject JNICALL
795 Java_com_redhat_et_libguestfs_GuestFS__1test0rstat
796   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
797 {
798   guestfs_h *g = (guestfs_h *) (long) jg;
799   jobject jr;
800   jclass cl;
801   jfieldID fl;
802   struct guestfs_stat *r;
803   const char *val;
804
805   val = (*env)->GetStringUTFChars (env, jval, NULL);
806   r = guestfs_test0rstat (g, val);
807   (*env)->ReleaseStringUTFChars (env, jval, val);
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/Stat");
813   jr = (*env)->AllocObject (env, cl);
814   fl = (*env)->GetFieldID (env, cl, "dev", "J");
815   (*env)->SetLongField (env, jr, fl, r->dev);
816   fl = (*env)->GetFieldID (env, cl, "ino", "J");
817   (*env)->SetLongField (env, jr, fl, r->ino);
818   fl = (*env)->GetFieldID (env, cl, "mode", "J");
819   (*env)->SetLongField (env, jr, fl, r->mode);
820   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
821   (*env)->SetLongField (env, jr, fl, r->nlink);
822   fl = (*env)->GetFieldID (env, cl, "uid", "J");
823   (*env)->SetLongField (env, jr, fl, r->uid);
824   fl = (*env)->GetFieldID (env, cl, "gid", "J");
825   (*env)->SetLongField (env, jr, fl, r->gid);
826   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
827   (*env)->SetLongField (env, jr, fl, r->rdev);
828   fl = (*env)->GetFieldID (env, cl, "size", "J");
829   (*env)->SetLongField (env, jr, fl, r->size);
830   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
831   (*env)->SetLongField (env, jr, fl, r->blksize);
832   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
833   (*env)->SetLongField (env, jr, fl, r->blocks);
834   fl = (*env)->GetFieldID (env, cl, "atime", "J");
835   (*env)->SetLongField (env, jr, fl, r->atime);
836   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
837   (*env)->SetLongField (env, jr, fl, r->mtime);
838   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
839   (*env)->SetLongField (env, jr, fl, r->ctime);
840   free (r);
841   return jr;
842 }
843
844 JNIEXPORT jobject JNICALL
845 Java_com_redhat_et_libguestfs_GuestFS__1test0rstaterr
846   (JNIEnv *env, jobject obj, jlong jg)
847 {
848   guestfs_h *g = (guestfs_h *) (long) jg;
849   jobject jr;
850   jclass cl;
851   jfieldID fl;
852   struct guestfs_stat *r;
853
854   r = guestfs_test0rstaterr (g);
855   if (r == NULL) {
856     throw_exception (env, guestfs_last_error (g));
857     return NULL;
858   }
859   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
860   jr = (*env)->AllocObject (env, cl);
861   fl = (*env)->GetFieldID (env, cl, "dev", "J");
862   (*env)->SetLongField (env, jr, fl, r->dev);
863   fl = (*env)->GetFieldID (env, cl, "ino", "J");
864   (*env)->SetLongField (env, jr, fl, r->ino);
865   fl = (*env)->GetFieldID (env, cl, "mode", "J");
866   (*env)->SetLongField (env, jr, fl, r->mode);
867   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
868   (*env)->SetLongField (env, jr, fl, r->nlink);
869   fl = (*env)->GetFieldID (env, cl, "uid", "J");
870   (*env)->SetLongField (env, jr, fl, r->uid);
871   fl = (*env)->GetFieldID (env, cl, "gid", "J");
872   (*env)->SetLongField (env, jr, fl, r->gid);
873   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
874   (*env)->SetLongField (env, jr, fl, r->rdev);
875   fl = (*env)->GetFieldID (env, cl, "size", "J");
876   (*env)->SetLongField (env, jr, fl, r->size);
877   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
878   (*env)->SetLongField (env, jr, fl, r->blksize);
879   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
880   (*env)->SetLongField (env, jr, fl, r->blocks);
881   fl = (*env)->GetFieldID (env, cl, "atime", "J");
882   (*env)->SetLongField (env, jr, fl, r->atime);
883   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
884   (*env)->SetLongField (env, jr, fl, r->mtime);
885   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
886   (*env)->SetLongField (env, jr, fl, r->ctime);
887   free (r);
888   return jr;
889 }
890
891 JNIEXPORT jobject JNICALL
892 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfs
893   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
894 {
895   guestfs_h *g = (guestfs_h *) (long) jg;
896   jobject jr;
897   jclass cl;
898   jfieldID fl;
899   struct guestfs_statvfs *r;
900   const char *val;
901
902   val = (*env)->GetStringUTFChars (env, jval, NULL);
903   r = guestfs_test0rstatvfs (g, val);
904   (*env)->ReleaseStringUTFChars (env, jval, val);
905   if (r == NULL) {
906     throw_exception (env, guestfs_last_error (g));
907     return NULL;
908   }
909   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
910   jr = (*env)->AllocObject (env, cl);
911   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
912   (*env)->SetLongField (env, jr, fl, r->bsize);
913   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
914   (*env)->SetLongField (env, jr, fl, r->frsize);
915   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
916   (*env)->SetLongField (env, jr, fl, r->blocks);
917   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
918   (*env)->SetLongField (env, jr, fl, r->bfree);
919   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
920   (*env)->SetLongField (env, jr, fl, r->bavail);
921   fl = (*env)->GetFieldID (env, cl, "files", "J");
922   (*env)->SetLongField (env, jr, fl, r->files);
923   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
924   (*env)->SetLongField (env, jr, fl, r->ffree);
925   fl = (*env)->GetFieldID (env, cl, "favail", "J");
926   (*env)->SetLongField (env, jr, fl, r->favail);
927   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
928   (*env)->SetLongField (env, jr, fl, r->fsid);
929   fl = (*env)->GetFieldID (env, cl, "flag", "J");
930   (*env)->SetLongField (env, jr, fl, r->flag);
931   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
932   (*env)->SetLongField (env, jr, fl, r->namemax);
933   free (r);
934   return jr;
935 }
936
937 JNIEXPORT jobject JNICALL
938 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfserr
939   (JNIEnv *env, jobject obj, jlong jg)
940 {
941   guestfs_h *g = (guestfs_h *) (long) jg;
942   jobject jr;
943   jclass cl;
944   jfieldID fl;
945   struct guestfs_statvfs *r;
946
947   r = guestfs_test0rstatvfserr (g);
948   if (r == NULL) {
949     throw_exception (env, guestfs_last_error (g));
950     return NULL;
951   }
952   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
953   jr = (*env)->AllocObject (env, cl);
954   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
955   (*env)->SetLongField (env, jr, fl, r->bsize);
956   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
957   (*env)->SetLongField (env, jr, fl, r->frsize);
958   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
959   (*env)->SetLongField (env, jr, fl, r->blocks);
960   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
961   (*env)->SetLongField (env, jr, fl, r->bfree);
962   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
963   (*env)->SetLongField (env, jr, fl, r->bavail);
964   fl = (*env)->GetFieldID (env, cl, "files", "J");
965   (*env)->SetLongField (env, jr, fl, r->files);
966   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
967   (*env)->SetLongField (env, jr, fl, r->ffree);
968   fl = (*env)->GetFieldID (env, cl, "favail", "J");
969   (*env)->SetLongField (env, jr, fl, r->favail);
970   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
971   (*env)->SetLongField (env, jr, fl, r->fsid);
972   fl = (*env)->GetFieldID (env, cl, "flag", "J");
973   (*env)->SetLongField (env, jr, fl, r->flag);
974   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
975   (*env)->SetLongField (env, jr, fl, r->namemax);
976   free (r);
977   return jr;
978 }
979
980 JNIEXPORT jobject JNICALL
981 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtable
982   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
983 {
984   guestfs_h *g = (guestfs_h *) (long) jg;
985   char **r;
986   const char *val;
987
988   val = (*env)->GetStringUTFChars (env, jval, NULL);
989   r = guestfs_test0rhashtable (g, val);
990   (*env)->ReleaseStringUTFChars (env, jval, val);
991   if (r == NULL) {
992     throw_exception (env, guestfs_last_error (g));
993     return NULL;
994   }
995   throw_exception (env, "test0rhashtable: internal error: please let us know how to make a Java HashMap from JNI bindings!");
996   return NULL;
997 }
998
999 JNIEXPORT jobject JNICALL
1000 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtableerr
1001   (JNIEnv *env, jobject obj, jlong jg)
1002 {
1003   guestfs_h *g = (guestfs_h *) (long) jg;
1004   char **r;
1005
1006   r = guestfs_test0rhashtableerr (g);
1007   if (r == NULL) {
1008     throw_exception (env, guestfs_last_error (g));
1009     return NULL;
1010   }
1011   throw_exception (env, "test0rhashtableerr: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1012   return NULL;
1013 }
1014
1015 JNIEXPORT void JNICALL
1016 Java_com_redhat_et_libguestfs_GuestFS__1launch
1017   (JNIEnv *env, jobject obj, jlong jg)
1018 {
1019   guestfs_h *g = (guestfs_h *) (long) jg;
1020   int r;
1021
1022   r = guestfs_launch (g);
1023   if (r == -1) {
1024     throw_exception (env, guestfs_last_error (g));
1025     return ;
1026   }
1027 }
1028
1029 JNIEXPORT void JNICALL
1030 Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
1031   (JNIEnv *env, jobject obj, jlong jg)
1032 {
1033   guestfs_h *g = (guestfs_h *) (long) jg;
1034   int r;
1035
1036   r = guestfs_wait_ready (g);
1037   if (r == -1) {
1038     throw_exception (env, guestfs_last_error (g));
1039     return ;
1040   }
1041 }
1042
1043 JNIEXPORT void JNICALL
1044 Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
1045   (JNIEnv *env, jobject obj, jlong jg)
1046 {
1047   guestfs_h *g = (guestfs_h *) (long) jg;
1048   int r;
1049
1050   r = guestfs_kill_subprocess (g);
1051   if (r == -1) {
1052     throw_exception (env, guestfs_last_error (g));
1053     return ;
1054   }
1055 }
1056
1057 JNIEXPORT void JNICALL
1058 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
1059   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1060 {
1061   guestfs_h *g = (guestfs_h *) (long) jg;
1062   int r;
1063   const char *filename;
1064
1065   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1066   r = guestfs_add_drive (g, filename);
1067   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1068   if (r == -1) {
1069     throw_exception (env, guestfs_last_error (g));
1070     return ;
1071   }
1072 }
1073
1074 JNIEXPORT void JNICALL
1075 Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
1076   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1077 {
1078   guestfs_h *g = (guestfs_h *) (long) jg;
1079   int r;
1080   const char *filename;
1081
1082   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1083   r = guestfs_add_cdrom (g, filename);
1084   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1085   if (r == -1) {
1086     throw_exception (env, guestfs_last_error (g));
1087     return ;
1088   }
1089 }
1090
1091 JNIEXPORT void JNICALL
1092 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive_1ro
1093   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1094 {
1095   guestfs_h *g = (guestfs_h *) (long) jg;
1096   int r;
1097   const char *filename;
1098
1099   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1100   r = guestfs_add_drive_ro (g, filename);
1101   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1102   if (r == -1) {
1103     throw_exception (env, guestfs_last_error (g));
1104     return ;
1105   }
1106 }
1107
1108 JNIEXPORT void JNICALL
1109 Java_com_redhat_et_libguestfs_GuestFS__1config
1110   (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
1111 {
1112   guestfs_h *g = (guestfs_h *) (long) jg;
1113   int r;
1114   const char *qemuparam;
1115   const char *qemuvalue;
1116
1117   qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
1118   qemuvalue = jqemuvalue ? (*env)->GetStringUTFChars (env, jqemuvalue, NULL) : NULL;
1119   r = guestfs_config (g, qemuparam, qemuvalue);
1120   (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
1121   if (jqemuvalue)
1122     (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
1123   if (r == -1) {
1124     throw_exception (env, guestfs_last_error (g));
1125     return ;
1126   }
1127 }
1128
1129 JNIEXPORT void JNICALL
1130 Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
1131   (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
1132 {
1133   guestfs_h *g = (guestfs_h *) (long) jg;
1134   int r;
1135   const char *qemu;
1136
1137   qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
1138   r = guestfs_set_qemu (g, qemu);
1139   (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
1140   if (r == -1) {
1141     throw_exception (env, guestfs_last_error (g));
1142     return ;
1143   }
1144 }
1145
1146 JNIEXPORT jstring JNICALL
1147 Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
1148   (JNIEnv *env, jobject obj, jlong jg)
1149 {
1150   guestfs_h *g = (guestfs_h *) (long) jg;
1151   const char *r;
1152
1153   r = guestfs_get_qemu (g);
1154   if (r == NULL) {
1155     throw_exception (env, guestfs_last_error (g));
1156     return NULL;
1157   }
1158   return (*env)->NewStringUTF (env, r);
1159 }
1160
1161 JNIEXPORT void JNICALL
1162 Java_com_redhat_et_libguestfs_GuestFS__1set_1path
1163   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1164 {
1165   guestfs_h *g = (guestfs_h *) (long) jg;
1166   int r;
1167   const char *path;
1168
1169   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1170   r = guestfs_set_path (g, path);
1171   (*env)->ReleaseStringUTFChars (env, jpath, path);
1172   if (r == -1) {
1173     throw_exception (env, guestfs_last_error (g));
1174     return ;
1175   }
1176 }
1177
1178 JNIEXPORT jstring JNICALL
1179 Java_com_redhat_et_libguestfs_GuestFS__1get_1path
1180   (JNIEnv *env, jobject obj, jlong jg)
1181 {
1182   guestfs_h *g = (guestfs_h *) (long) jg;
1183   const char *r;
1184
1185   r = guestfs_get_path (g);
1186   if (r == NULL) {
1187     throw_exception (env, guestfs_last_error (g));
1188     return NULL;
1189   }
1190   return (*env)->NewStringUTF (env, r);
1191 }
1192
1193 JNIEXPORT void JNICALL
1194 Java_com_redhat_et_libguestfs_GuestFS__1set_1append
1195   (JNIEnv *env, jobject obj, jlong jg, jstring jappend)
1196 {
1197   guestfs_h *g = (guestfs_h *) (long) jg;
1198   int r;
1199   const char *append;
1200
1201   append = (*env)->GetStringUTFChars (env, jappend, NULL);
1202   r = guestfs_set_append (g, append);
1203   (*env)->ReleaseStringUTFChars (env, jappend, append);
1204   if (r == -1) {
1205     throw_exception (env, guestfs_last_error (g));
1206     return ;
1207   }
1208 }
1209
1210 JNIEXPORT jstring JNICALL
1211 Java_com_redhat_et_libguestfs_GuestFS__1get_1append
1212   (JNIEnv *env, jobject obj, jlong jg)
1213 {
1214   guestfs_h *g = (guestfs_h *) (long) jg;
1215   const char *r;
1216
1217   r = guestfs_get_append (g);
1218   if (r == NULL) {
1219     throw_exception (env, guestfs_last_error (g));
1220     return NULL;
1221   }
1222   return (*env)->NewStringUTF (env, r);
1223 }
1224
1225 JNIEXPORT void JNICALL
1226 Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
1227   (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
1228 {
1229   guestfs_h *g = (guestfs_h *) (long) jg;
1230   int r;
1231   int autosync;
1232
1233   autosync = jautosync;
1234   r = guestfs_set_autosync (g, autosync);
1235   if (r == -1) {
1236     throw_exception (env, guestfs_last_error (g));
1237     return ;
1238   }
1239 }
1240
1241 JNIEXPORT jboolean JNICALL
1242 Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
1243   (JNIEnv *env, jobject obj, jlong jg)
1244 {
1245   guestfs_h *g = (guestfs_h *) (long) jg;
1246   int r;
1247
1248   r = guestfs_get_autosync (g);
1249   if (r == -1) {
1250     throw_exception (env, guestfs_last_error (g));
1251     return 0;
1252   }
1253   return (jboolean) r;
1254 }
1255
1256 JNIEXPORT void JNICALL
1257 Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
1258   (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
1259 {
1260   guestfs_h *g = (guestfs_h *) (long) jg;
1261   int r;
1262   int verbose;
1263
1264   verbose = jverbose;
1265   r = guestfs_set_verbose (g, verbose);
1266   if (r == -1) {
1267     throw_exception (env, guestfs_last_error (g));
1268     return ;
1269   }
1270 }
1271
1272 JNIEXPORT jboolean JNICALL
1273 Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
1274   (JNIEnv *env, jobject obj, jlong jg)
1275 {
1276   guestfs_h *g = (guestfs_h *) (long) jg;
1277   int r;
1278
1279   r = guestfs_get_verbose (g);
1280   if (r == -1) {
1281     throw_exception (env, guestfs_last_error (g));
1282     return 0;
1283   }
1284   return (jboolean) r;
1285 }
1286
1287 JNIEXPORT jboolean JNICALL
1288 Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
1289   (JNIEnv *env, jobject obj, jlong jg)
1290 {
1291   guestfs_h *g = (guestfs_h *) (long) jg;
1292   int r;
1293
1294   r = guestfs_is_ready (g);
1295   if (r == -1) {
1296     throw_exception (env, guestfs_last_error (g));
1297     return 0;
1298   }
1299   return (jboolean) r;
1300 }
1301
1302 JNIEXPORT jboolean JNICALL
1303 Java_com_redhat_et_libguestfs_GuestFS__1is_1config
1304   (JNIEnv *env, jobject obj, jlong jg)
1305 {
1306   guestfs_h *g = (guestfs_h *) (long) jg;
1307   int r;
1308
1309   r = guestfs_is_config (g);
1310   if (r == -1) {
1311     throw_exception (env, guestfs_last_error (g));
1312     return 0;
1313   }
1314   return (jboolean) r;
1315 }
1316
1317 JNIEXPORT jboolean JNICALL
1318 Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
1319   (JNIEnv *env, jobject obj, jlong jg)
1320 {
1321   guestfs_h *g = (guestfs_h *) (long) jg;
1322   int r;
1323
1324   r = guestfs_is_launching (g);
1325   if (r == -1) {
1326     throw_exception (env, guestfs_last_error (g));
1327     return 0;
1328   }
1329   return (jboolean) r;
1330 }
1331
1332 JNIEXPORT jboolean JNICALL
1333 Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
1334   (JNIEnv *env, jobject obj, jlong jg)
1335 {
1336   guestfs_h *g = (guestfs_h *) (long) jg;
1337   int r;
1338
1339   r = guestfs_is_busy (g);
1340   if (r == -1) {
1341     throw_exception (env, guestfs_last_error (g));
1342     return 0;
1343   }
1344   return (jboolean) r;
1345 }
1346
1347 JNIEXPORT jint JNICALL
1348 Java_com_redhat_et_libguestfs_GuestFS__1get_1state
1349   (JNIEnv *env, jobject obj, jlong jg)
1350 {
1351   guestfs_h *g = (guestfs_h *) (long) jg;
1352   int r;
1353
1354   r = guestfs_get_state (g);
1355   if (r == -1) {
1356     throw_exception (env, guestfs_last_error (g));
1357     return 0;
1358   }
1359   return (jint) r;
1360 }
1361
1362 JNIEXPORT void JNICALL
1363 Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
1364   (JNIEnv *env, jobject obj, jlong jg)
1365 {
1366   guestfs_h *g = (guestfs_h *) (long) jg;
1367   int r;
1368
1369   r = guestfs_set_busy (g);
1370   if (r == -1) {
1371     throw_exception (env, guestfs_last_error (g));
1372     return ;
1373   }
1374 }
1375
1376 JNIEXPORT void JNICALL
1377 Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
1378   (JNIEnv *env, jobject obj, jlong jg)
1379 {
1380   guestfs_h *g = (guestfs_h *) (long) jg;
1381   int r;
1382
1383   r = guestfs_set_ready (g);
1384   if (r == -1) {
1385     throw_exception (env, guestfs_last_error (g));
1386     return ;
1387   }
1388 }
1389
1390 JNIEXPORT void JNICALL
1391 Java_com_redhat_et_libguestfs_GuestFS__1end_1busy
1392   (JNIEnv *env, jobject obj, jlong jg)
1393 {
1394   guestfs_h *g = (guestfs_h *) (long) jg;
1395   int r;
1396
1397   r = guestfs_end_busy (g);
1398   if (r == -1) {
1399     throw_exception (env, guestfs_last_error (g));
1400     return ;
1401   }
1402 }
1403
1404 JNIEXPORT void JNICALL
1405 Java_com_redhat_et_libguestfs_GuestFS__1set_1memsize
1406   (JNIEnv *env, jobject obj, jlong jg, jint jmemsize)
1407 {
1408   guestfs_h *g = (guestfs_h *) (long) jg;
1409   int r;
1410   int memsize;
1411
1412   memsize = jmemsize;
1413   r = guestfs_set_memsize (g, memsize);
1414   if (r == -1) {
1415     throw_exception (env, guestfs_last_error (g));
1416     return ;
1417   }
1418 }
1419
1420 JNIEXPORT jint JNICALL
1421 Java_com_redhat_et_libguestfs_GuestFS__1get_1memsize
1422   (JNIEnv *env, jobject obj, jlong jg)
1423 {
1424   guestfs_h *g = (guestfs_h *) (long) jg;
1425   int r;
1426
1427   r = guestfs_get_memsize (g);
1428   if (r == -1) {
1429     throw_exception (env, guestfs_last_error (g));
1430     return 0;
1431   }
1432   return (jint) r;
1433 }
1434
1435 JNIEXPORT void JNICALL
1436 Java_com_redhat_et_libguestfs_GuestFS__1mount
1437   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
1438 {
1439   guestfs_h *g = (guestfs_h *) (long) jg;
1440   int r;
1441   const char *device;
1442   const char *mountpoint;
1443
1444   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1445   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
1446   r = guestfs_mount (g, device, mountpoint);
1447   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1448   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
1449   if (r == -1) {
1450     throw_exception (env, guestfs_last_error (g));
1451     return ;
1452   }
1453 }
1454
1455 JNIEXPORT void JNICALL
1456 Java_com_redhat_et_libguestfs_GuestFS__1sync
1457   (JNIEnv *env, jobject obj, jlong jg)
1458 {
1459   guestfs_h *g = (guestfs_h *) (long) jg;
1460   int r;
1461
1462   r = guestfs_sync (g);
1463   if (r == -1) {
1464     throw_exception (env, guestfs_last_error (g));
1465     return ;
1466   }
1467 }
1468
1469 JNIEXPORT void JNICALL
1470 Java_com_redhat_et_libguestfs_GuestFS__1touch
1471   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1472 {
1473   guestfs_h *g = (guestfs_h *) (long) jg;
1474   int r;
1475   const char *path;
1476
1477   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1478   r = guestfs_touch (g, path);
1479   (*env)->ReleaseStringUTFChars (env, jpath, path);
1480   if (r == -1) {
1481     throw_exception (env, guestfs_last_error (g));
1482     return ;
1483   }
1484 }
1485
1486 JNIEXPORT jstring JNICALL
1487 Java_com_redhat_et_libguestfs_GuestFS__1cat
1488   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1489 {
1490   guestfs_h *g = (guestfs_h *) (long) jg;
1491   jstring jr;
1492   char *r;
1493   const char *path;
1494
1495   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1496   r = guestfs_cat (g, path);
1497   (*env)->ReleaseStringUTFChars (env, jpath, path);
1498   if (r == NULL) {
1499     throw_exception (env, guestfs_last_error (g));
1500     return NULL;
1501   }
1502   jr = (*env)->NewStringUTF (env, r);
1503   free (r);
1504   return jr;
1505 }
1506
1507 JNIEXPORT jstring JNICALL
1508 Java_com_redhat_et_libguestfs_GuestFS__1ll
1509   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1510 {
1511   guestfs_h *g = (guestfs_h *) (long) jg;
1512   jstring jr;
1513   char *r;
1514   const char *directory;
1515
1516   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1517   r = guestfs_ll (g, directory);
1518   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1519   if (r == NULL) {
1520     throw_exception (env, guestfs_last_error (g));
1521     return NULL;
1522   }
1523   jr = (*env)->NewStringUTF (env, r);
1524   free (r);
1525   return jr;
1526 }
1527
1528 JNIEXPORT jobjectArray JNICALL
1529 Java_com_redhat_et_libguestfs_GuestFS__1ls
1530   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1531 {
1532   guestfs_h *g = (guestfs_h *) (long) jg;
1533   jobjectArray jr;
1534   int r_len;
1535   jclass cl;
1536   jstring jstr;
1537   char **r;
1538   const char *directory;
1539   int i;
1540
1541   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1542   r = guestfs_ls (g, directory);
1543   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1544   if (r == NULL) {
1545     throw_exception (env, guestfs_last_error (g));
1546     return NULL;
1547   }
1548   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1549   cl = (*env)->FindClass (env, "java/lang/String");
1550   jstr = (*env)->NewStringUTF (env, "");
1551   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1552   for (i = 0; i < r_len; ++i) {
1553     jstr = (*env)->NewStringUTF (env, r[i]);
1554     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1555     free (r[i]);
1556   }
1557   free (r);
1558   return jr;
1559 }
1560
1561 JNIEXPORT jobjectArray JNICALL
1562 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
1563   (JNIEnv *env, jobject obj, jlong jg)
1564 {
1565   guestfs_h *g = (guestfs_h *) (long) jg;
1566   jobjectArray jr;
1567   int r_len;
1568   jclass cl;
1569   jstring jstr;
1570   char **r;
1571   int i;
1572
1573   r = guestfs_list_devices (g);
1574   if (r == NULL) {
1575     throw_exception (env, guestfs_last_error (g));
1576     return NULL;
1577   }
1578   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1579   cl = (*env)->FindClass (env, "java/lang/String");
1580   jstr = (*env)->NewStringUTF (env, "");
1581   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1582   for (i = 0; i < r_len; ++i) {
1583     jstr = (*env)->NewStringUTF (env, r[i]);
1584     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1585     free (r[i]);
1586   }
1587   free (r);
1588   return jr;
1589 }
1590
1591 JNIEXPORT jobjectArray JNICALL
1592 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
1593   (JNIEnv *env, jobject obj, jlong jg)
1594 {
1595   guestfs_h *g = (guestfs_h *) (long) jg;
1596   jobjectArray jr;
1597   int r_len;
1598   jclass cl;
1599   jstring jstr;
1600   char **r;
1601   int i;
1602
1603   r = guestfs_list_partitions (g);
1604   if (r == NULL) {
1605     throw_exception (env, guestfs_last_error (g));
1606     return NULL;
1607   }
1608   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1609   cl = (*env)->FindClass (env, "java/lang/String");
1610   jstr = (*env)->NewStringUTF (env, "");
1611   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1612   for (i = 0; i < r_len; ++i) {
1613     jstr = (*env)->NewStringUTF (env, r[i]);
1614     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1615     free (r[i]);
1616   }
1617   free (r);
1618   return jr;
1619 }
1620
1621 JNIEXPORT jobjectArray JNICALL
1622 Java_com_redhat_et_libguestfs_GuestFS__1pvs
1623   (JNIEnv *env, jobject obj, jlong jg)
1624 {
1625   guestfs_h *g = (guestfs_h *) (long) jg;
1626   jobjectArray jr;
1627   int r_len;
1628   jclass cl;
1629   jstring jstr;
1630   char **r;
1631   int i;
1632
1633   r = guestfs_pvs (g);
1634   if (r == NULL) {
1635     throw_exception (env, guestfs_last_error (g));
1636     return NULL;
1637   }
1638   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1639   cl = (*env)->FindClass (env, "java/lang/String");
1640   jstr = (*env)->NewStringUTF (env, "");
1641   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1642   for (i = 0; i < r_len; ++i) {
1643     jstr = (*env)->NewStringUTF (env, r[i]);
1644     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1645     free (r[i]);
1646   }
1647   free (r);
1648   return jr;
1649 }
1650
1651 JNIEXPORT jobjectArray JNICALL
1652 Java_com_redhat_et_libguestfs_GuestFS__1vgs
1653   (JNIEnv *env, jobject obj, jlong jg)
1654 {
1655   guestfs_h *g = (guestfs_h *) (long) jg;
1656   jobjectArray jr;
1657   int r_len;
1658   jclass cl;
1659   jstring jstr;
1660   char **r;
1661   int i;
1662
1663   r = guestfs_vgs (g);
1664   if (r == NULL) {
1665     throw_exception (env, guestfs_last_error (g));
1666     return NULL;
1667   }
1668   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1669   cl = (*env)->FindClass (env, "java/lang/String");
1670   jstr = (*env)->NewStringUTF (env, "");
1671   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1672   for (i = 0; i < r_len; ++i) {
1673     jstr = (*env)->NewStringUTF (env, r[i]);
1674     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1675     free (r[i]);
1676   }
1677   free (r);
1678   return jr;
1679 }
1680
1681 JNIEXPORT jobjectArray JNICALL
1682 Java_com_redhat_et_libguestfs_GuestFS__1lvs
1683   (JNIEnv *env, jobject obj, jlong jg)
1684 {
1685   guestfs_h *g = (guestfs_h *) (long) jg;
1686   jobjectArray jr;
1687   int r_len;
1688   jclass cl;
1689   jstring jstr;
1690   char **r;
1691   int i;
1692
1693   r = guestfs_lvs (g);
1694   if (r == NULL) {
1695     throw_exception (env, guestfs_last_error (g));
1696     return NULL;
1697   }
1698   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1699   cl = (*env)->FindClass (env, "java/lang/String");
1700   jstr = (*env)->NewStringUTF (env, "");
1701   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1702   for (i = 0; i < r_len; ++i) {
1703     jstr = (*env)->NewStringUTF (env, r[i]);
1704     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1705     free (r[i]);
1706   }
1707   free (r);
1708   return jr;
1709 }
1710
1711 JNIEXPORT jobjectArray JNICALL
1712 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
1713   (JNIEnv *env, jobject obj, jlong jg)
1714 {
1715   guestfs_h *g = (guestfs_h *) (long) jg;
1716   jobjectArray jr;
1717   jclass cl;
1718   jfieldID fl;
1719   jobject jfl;
1720   struct guestfs_lvm_pv_list *r;
1721   int i;
1722
1723   r = guestfs_pvs_full (g);
1724   if (r == NULL) {
1725     throw_exception (env, guestfs_last_error (g));
1726     return NULL;
1727   }
1728   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
1729   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1730   for (i = 0; i < r->len; ++i) {
1731     jfl = (*env)->AllocObject (env, cl);
1732     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
1733     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
1734     {
1735       char s[33];
1736       memcpy (s, r->val[i].pv_uuid, 32);
1737       s[32] = 0;
1738       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
1739       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1740     }
1741     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
1742     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
1743     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
1744     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
1745     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
1746     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
1747     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
1748     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
1749     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
1750     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
1751     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
1752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
1753     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
1754     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
1755     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
1756     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
1757     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
1758     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
1759     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
1760     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
1761     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
1762     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
1763     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
1764     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
1765     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1766   }
1767   guestfs_free_lvm_pv_list (r);
1768   return jr;
1769 }
1770
1771 JNIEXPORT jobjectArray JNICALL
1772 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
1773   (JNIEnv *env, jobject obj, jlong jg)
1774 {
1775   guestfs_h *g = (guestfs_h *) (long) jg;
1776   jobjectArray jr;
1777   jclass cl;
1778   jfieldID fl;
1779   jobject jfl;
1780   struct guestfs_lvm_vg_list *r;
1781   int i;
1782
1783   r = guestfs_vgs_full (g);
1784   if (r == NULL) {
1785     throw_exception (env, guestfs_last_error (g));
1786     return NULL;
1787   }
1788   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
1789   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1790   for (i = 0; i < r->len; ++i) {
1791     jfl = (*env)->AllocObject (env, cl);
1792     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
1793     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
1794     {
1795       char s[33];
1796       memcpy (s, r->val[i].vg_uuid, 32);
1797       s[32] = 0;
1798       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
1799       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1800     }
1801     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
1802     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
1803     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
1804     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
1805     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
1806     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
1807     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
1808     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
1809     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
1810     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
1811     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
1812     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
1813     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
1814     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
1815     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
1816     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
1817     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
1818     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
1819     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
1820     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
1821     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
1822     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
1823     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
1824     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
1825     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
1826     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
1827     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
1828     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
1829     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
1830     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
1831     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
1832     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
1833     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
1834     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
1835     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1836   }
1837   guestfs_free_lvm_vg_list (r);
1838   return jr;
1839 }
1840
1841 JNIEXPORT jobjectArray JNICALL
1842 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
1843   (JNIEnv *env, jobject obj, jlong jg)
1844 {
1845   guestfs_h *g = (guestfs_h *) (long) jg;
1846   jobjectArray jr;
1847   jclass cl;
1848   jfieldID fl;
1849   jobject jfl;
1850   struct guestfs_lvm_lv_list *r;
1851   int i;
1852
1853   r = guestfs_lvs_full (g);
1854   if (r == NULL) {
1855     throw_exception (env, guestfs_last_error (g));
1856     return NULL;
1857   }
1858   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
1859   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1860   for (i = 0; i < r->len; ++i) {
1861     jfl = (*env)->AllocObject (env, cl);
1862     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
1863     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
1864     {
1865       char s[33];
1866       memcpy (s, r->val[i].lv_uuid, 32);
1867       s[32] = 0;
1868       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
1869       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1870     }
1871     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
1872     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
1873     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
1874     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
1875     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
1876     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
1877     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
1878     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
1879     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
1880     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
1881     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
1882     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
1883     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
1884     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
1885     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
1886     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
1887     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
1888     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
1889     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
1890     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
1891     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
1892     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
1893     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
1894     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
1895     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
1896     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
1897     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
1898     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
1899     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1900   }
1901   guestfs_free_lvm_lv_list (r);
1902   return jr;
1903 }
1904
1905 JNIEXPORT jobjectArray JNICALL
1906 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
1907   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1908 {
1909   guestfs_h *g = (guestfs_h *) (long) jg;
1910   jobjectArray jr;
1911   int r_len;
1912   jclass cl;
1913   jstring jstr;
1914   char **r;
1915   const char *path;
1916   int i;
1917
1918   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1919   r = guestfs_read_lines (g, path);
1920   (*env)->ReleaseStringUTFChars (env, jpath, path);
1921   if (r == NULL) {
1922     throw_exception (env, guestfs_last_error (g));
1923     return NULL;
1924   }
1925   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1926   cl = (*env)->FindClass (env, "java/lang/String");
1927   jstr = (*env)->NewStringUTF (env, "");
1928   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1929   for (i = 0; i < r_len; ++i) {
1930     jstr = (*env)->NewStringUTF (env, r[i]);
1931     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1932     free (r[i]);
1933   }
1934   free (r);
1935   return jr;
1936 }
1937
1938 JNIEXPORT void JNICALL
1939 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
1940   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
1941 {
1942   guestfs_h *g = (guestfs_h *) (long) jg;
1943   int r;
1944   const char *root;
1945   int flags;
1946
1947   root = (*env)->GetStringUTFChars (env, jroot, NULL);
1948   flags = jflags;
1949   r = guestfs_aug_init (g, root, flags);
1950   (*env)->ReleaseStringUTFChars (env, jroot, root);
1951   if (r == -1) {
1952     throw_exception (env, guestfs_last_error (g));
1953     return ;
1954   }
1955 }
1956
1957 JNIEXPORT void JNICALL
1958 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
1959   (JNIEnv *env, jobject obj, jlong jg)
1960 {
1961   guestfs_h *g = (guestfs_h *) (long) jg;
1962   int r;
1963
1964   r = guestfs_aug_close (g);
1965   if (r == -1) {
1966     throw_exception (env, guestfs_last_error (g));
1967     return ;
1968   }
1969 }
1970
1971 JNIEXPORT jint JNICALL
1972 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
1973   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
1974 {
1975   guestfs_h *g = (guestfs_h *) (long) jg;
1976   int r;
1977   const char *name;
1978   const char *expr;
1979
1980   name = (*env)->GetStringUTFChars (env, jname, NULL);
1981   expr = jexpr ? (*env)->GetStringUTFChars (env, jexpr, NULL) : NULL;
1982   r = guestfs_aug_defvar (g, name, expr);
1983   (*env)->ReleaseStringUTFChars (env, jname, name);
1984   if (jexpr)
1985     (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1986   if (r == -1) {
1987     throw_exception (env, guestfs_last_error (g));
1988     return 0;
1989   }
1990   return (jint) r;
1991 }
1992
1993 JNIEXPORT jobject JNICALL
1994 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
1995   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
1996 {
1997   guestfs_h *g = (guestfs_h *) (long) jg;
1998   jobject jr;
1999   jclass cl;
2000   jfieldID fl;
2001   struct guestfs_int_bool *r;
2002   const char *name;
2003   const char *expr;
2004   const char *val;
2005
2006   name = (*env)->GetStringUTFChars (env, jname, NULL);
2007   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
2008   val = (*env)->GetStringUTFChars (env, jval, NULL);
2009   r = guestfs_aug_defnode (g, name, expr, val);
2010   (*env)->ReleaseStringUTFChars (env, jname, name);
2011   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
2012   (*env)->ReleaseStringUTFChars (env, jval, val);
2013   if (r == NULL) {
2014     throw_exception (env, guestfs_last_error (g));
2015     return NULL;
2016   }
2017   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
2018   jr = (*env)->AllocObject (env, cl);
2019   fl = (*env)->GetFieldID (env, cl, "i", "I");
2020   (*env)->SetIntField (env, jr, fl, r->i);
2021   fl = (*env)->GetFieldID (env, cl, "i", "Z");
2022   (*env)->SetBooleanField (env, jr, fl, r->b);
2023   guestfs_free_int_bool (r);
2024   return jr;
2025 }
2026
2027 JNIEXPORT jstring JNICALL
2028 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
2029   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2030 {
2031   guestfs_h *g = (guestfs_h *) (long) jg;
2032   jstring jr;
2033   char *r;
2034   const char *path;
2035
2036   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2037   r = guestfs_aug_get (g, path);
2038   (*env)->ReleaseStringUTFChars (env, jpath, path);
2039   if (r == NULL) {
2040     throw_exception (env, guestfs_last_error (g));
2041     return NULL;
2042   }
2043   jr = (*env)->NewStringUTF (env, r);
2044   free (r);
2045   return jr;
2046 }
2047
2048 JNIEXPORT void JNICALL
2049 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
2050   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
2051 {
2052   guestfs_h *g = (guestfs_h *) (long) jg;
2053   int r;
2054   const char *path;
2055   const char *val;
2056
2057   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2058   val = (*env)->GetStringUTFChars (env, jval, NULL);
2059   r = guestfs_aug_set (g, path, val);
2060   (*env)->ReleaseStringUTFChars (env, jpath, path);
2061   (*env)->ReleaseStringUTFChars (env, jval, val);
2062   if (r == -1) {
2063     throw_exception (env, guestfs_last_error (g));
2064     return ;
2065   }
2066 }
2067
2068 JNIEXPORT void JNICALL
2069 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
2070   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
2071 {
2072   guestfs_h *g = (guestfs_h *) (long) jg;
2073   int r;
2074   const char *path;
2075   const char *label;
2076   int before;
2077
2078   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2079   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2080   before = jbefore;
2081   r = guestfs_aug_insert (g, path, label, before);
2082   (*env)->ReleaseStringUTFChars (env, jpath, path);
2083   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2084   if (r == -1) {
2085     throw_exception (env, guestfs_last_error (g));
2086     return ;
2087   }
2088 }
2089
2090 JNIEXPORT jint JNICALL
2091 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
2092   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2093 {
2094   guestfs_h *g = (guestfs_h *) (long) jg;
2095   int r;
2096   const char *path;
2097
2098   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2099   r = guestfs_aug_rm (g, path);
2100   (*env)->ReleaseStringUTFChars (env, jpath, path);
2101   if (r == -1) {
2102     throw_exception (env, guestfs_last_error (g));
2103     return 0;
2104   }
2105   return (jint) r;
2106 }
2107
2108 JNIEXPORT void JNICALL
2109 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
2110   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2111 {
2112   guestfs_h *g = (guestfs_h *) (long) jg;
2113   int r;
2114   const char *src;
2115   const char *dest;
2116
2117   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2118   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2119   r = guestfs_aug_mv (g, src, dest);
2120   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2121   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2122   if (r == -1) {
2123     throw_exception (env, guestfs_last_error (g));
2124     return ;
2125   }
2126 }
2127
2128 JNIEXPORT jobjectArray JNICALL
2129 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
2130   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2131 {
2132   guestfs_h *g = (guestfs_h *) (long) jg;
2133   jobjectArray jr;
2134   int r_len;
2135   jclass cl;
2136   jstring jstr;
2137   char **r;
2138   const char *path;
2139   int i;
2140
2141   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2142   r = guestfs_aug_match (g, path);
2143   (*env)->ReleaseStringUTFChars (env, jpath, path);
2144   if (r == NULL) {
2145     throw_exception (env, guestfs_last_error (g));
2146     return NULL;
2147   }
2148   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2149   cl = (*env)->FindClass (env, "java/lang/String");
2150   jstr = (*env)->NewStringUTF (env, "");
2151   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2152   for (i = 0; i < r_len; ++i) {
2153     jstr = (*env)->NewStringUTF (env, r[i]);
2154     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2155     free (r[i]);
2156   }
2157   free (r);
2158   return jr;
2159 }
2160
2161 JNIEXPORT void JNICALL
2162 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
2163   (JNIEnv *env, jobject obj, jlong jg)
2164 {
2165   guestfs_h *g = (guestfs_h *) (long) jg;
2166   int r;
2167
2168   r = guestfs_aug_save (g);
2169   if (r == -1) {
2170     throw_exception (env, guestfs_last_error (g));
2171     return ;
2172   }
2173 }
2174
2175 JNIEXPORT void JNICALL
2176 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
2177   (JNIEnv *env, jobject obj, jlong jg)
2178 {
2179   guestfs_h *g = (guestfs_h *) (long) jg;
2180   int r;
2181
2182   r = guestfs_aug_load (g);
2183   if (r == -1) {
2184     throw_exception (env, guestfs_last_error (g));
2185     return ;
2186   }
2187 }
2188
2189 JNIEXPORT jobjectArray JNICALL
2190 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
2191   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2192 {
2193   guestfs_h *g = (guestfs_h *) (long) jg;
2194   jobjectArray jr;
2195   int r_len;
2196   jclass cl;
2197   jstring jstr;
2198   char **r;
2199   const char *path;
2200   int i;
2201
2202   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2203   r = guestfs_aug_ls (g, path);
2204   (*env)->ReleaseStringUTFChars (env, jpath, path);
2205   if (r == NULL) {
2206     throw_exception (env, guestfs_last_error (g));
2207     return NULL;
2208   }
2209   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2210   cl = (*env)->FindClass (env, "java/lang/String");
2211   jstr = (*env)->NewStringUTF (env, "");
2212   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2213   for (i = 0; i < r_len; ++i) {
2214     jstr = (*env)->NewStringUTF (env, r[i]);
2215     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2216     free (r[i]);
2217   }
2218   free (r);
2219   return jr;
2220 }
2221
2222 JNIEXPORT void JNICALL
2223 Java_com_redhat_et_libguestfs_GuestFS__1rm
2224   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2225 {
2226   guestfs_h *g = (guestfs_h *) (long) jg;
2227   int r;
2228   const char *path;
2229
2230   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2231   r = guestfs_rm (g, path);
2232   (*env)->ReleaseStringUTFChars (env, jpath, path);
2233   if (r == -1) {
2234     throw_exception (env, guestfs_last_error (g));
2235     return ;
2236   }
2237 }
2238
2239 JNIEXPORT void JNICALL
2240 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
2241   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2242 {
2243   guestfs_h *g = (guestfs_h *) (long) jg;
2244   int r;
2245   const char *path;
2246
2247   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2248   r = guestfs_rmdir (g, path);
2249   (*env)->ReleaseStringUTFChars (env, jpath, path);
2250   if (r == -1) {
2251     throw_exception (env, guestfs_last_error (g));
2252     return ;
2253   }
2254 }
2255
2256 JNIEXPORT void JNICALL
2257 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
2258   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2259 {
2260   guestfs_h *g = (guestfs_h *) (long) jg;
2261   int r;
2262   const char *path;
2263
2264   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2265   r = guestfs_rm_rf (g, path);
2266   (*env)->ReleaseStringUTFChars (env, jpath, path);
2267   if (r == -1) {
2268     throw_exception (env, guestfs_last_error (g));
2269     return ;
2270   }
2271 }
2272
2273 JNIEXPORT void JNICALL
2274 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
2275   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2276 {
2277   guestfs_h *g = (guestfs_h *) (long) jg;
2278   int r;
2279   const char *path;
2280
2281   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2282   r = guestfs_mkdir (g, path);
2283   (*env)->ReleaseStringUTFChars (env, jpath, path);
2284   if (r == -1) {
2285     throw_exception (env, guestfs_last_error (g));
2286     return ;
2287   }
2288 }
2289
2290 JNIEXPORT void JNICALL
2291 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
2292   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2293 {
2294   guestfs_h *g = (guestfs_h *) (long) jg;
2295   int r;
2296   const char *path;
2297
2298   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2299   r = guestfs_mkdir_p (g, path);
2300   (*env)->ReleaseStringUTFChars (env, jpath, path);
2301   if (r == -1) {
2302     throw_exception (env, guestfs_last_error (g));
2303     return ;
2304   }
2305 }
2306
2307 JNIEXPORT void JNICALL
2308 Java_com_redhat_et_libguestfs_GuestFS__1chmod
2309   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
2310 {
2311   guestfs_h *g = (guestfs_h *) (long) jg;
2312   int r;
2313   int mode;
2314   const char *path;
2315
2316   mode = jmode;
2317   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2318   r = guestfs_chmod (g, mode, path);
2319   (*env)->ReleaseStringUTFChars (env, jpath, path);
2320   if (r == -1) {
2321     throw_exception (env, guestfs_last_error (g));
2322     return ;
2323   }
2324 }
2325
2326 JNIEXPORT void JNICALL
2327 Java_com_redhat_et_libguestfs_GuestFS__1chown
2328   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
2329 {
2330   guestfs_h *g = (guestfs_h *) (long) jg;
2331   int r;
2332   int owner;
2333   int group;
2334   const char *path;
2335
2336   owner = jowner;
2337   group = jgroup;
2338   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2339   r = guestfs_chown (g, owner, group, path);
2340   (*env)->ReleaseStringUTFChars (env, jpath, path);
2341   if (r == -1) {
2342     throw_exception (env, guestfs_last_error (g));
2343     return ;
2344   }
2345 }
2346
2347 JNIEXPORT jboolean JNICALL
2348 Java_com_redhat_et_libguestfs_GuestFS__1exists
2349   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2350 {
2351   guestfs_h *g = (guestfs_h *) (long) jg;
2352   int r;
2353   const char *path;
2354
2355   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2356   r = guestfs_exists (g, path);
2357   (*env)->ReleaseStringUTFChars (env, jpath, path);
2358   if (r == -1) {
2359     throw_exception (env, guestfs_last_error (g));
2360     return 0;
2361   }
2362   return (jboolean) r;
2363 }
2364
2365 JNIEXPORT jboolean JNICALL
2366 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
2367   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2368 {
2369   guestfs_h *g = (guestfs_h *) (long) jg;
2370   int r;
2371   const char *path;
2372
2373   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2374   r = guestfs_is_file (g, path);
2375   (*env)->ReleaseStringUTFChars (env, jpath, path);
2376   if (r == -1) {
2377     throw_exception (env, guestfs_last_error (g));
2378     return 0;
2379   }
2380   return (jboolean) r;
2381 }
2382
2383 JNIEXPORT jboolean JNICALL
2384 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
2385   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2386 {
2387   guestfs_h *g = (guestfs_h *) (long) jg;
2388   int r;
2389   const char *path;
2390
2391   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2392   r = guestfs_is_dir (g, path);
2393   (*env)->ReleaseStringUTFChars (env, jpath, path);
2394   if (r == -1) {
2395     throw_exception (env, guestfs_last_error (g));
2396     return 0;
2397   }
2398   return (jboolean) r;
2399 }
2400
2401 JNIEXPORT void JNICALL
2402 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
2403   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2404 {
2405   guestfs_h *g = (guestfs_h *) (long) jg;
2406   int r;
2407   const char *device;
2408
2409   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2410   r = guestfs_pvcreate (g, device);
2411   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2412   if (r == -1) {
2413     throw_exception (env, guestfs_last_error (g));
2414     return ;
2415   }
2416 }
2417
2418 JNIEXPORT void JNICALL
2419 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
2420   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
2421 {
2422   guestfs_h *g = (guestfs_h *) (long) jg;
2423   int r;
2424   const char *volgroup;
2425   int physvols_len;
2426   const char **physvols;
2427   int i;
2428
2429   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2430   physvols_len = (*env)->GetArrayLength (env, jphysvols);
2431   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
2432   for (i = 0; i < physvols_len; ++i) {
2433     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2434     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
2435   }
2436   physvols[physvols_len] = NULL;
2437   r = guestfs_vgcreate (g, volgroup, physvols);
2438   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2439   for (i = 0; i < physvols_len; ++i) {
2440     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2441     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
2442   }
2443   free (physvols);
2444   if (r == -1) {
2445     throw_exception (env, guestfs_last_error (g));
2446     return ;
2447   }
2448 }
2449
2450 JNIEXPORT void JNICALL
2451 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
2452   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
2453 {
2454   guestfs_h *g = (guestfs_h *) (long) jg;
2455   int r;
2456   const char *logvol;
2457   const char *volgroup;
2458   int mbytes;
2459
2460   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
2461   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2462   mbytes = jmbytes;
2463   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2464   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
2465   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2466   if (r == -1) {
2467     throw_exception (env, guestfs_last_error (g));
2468     return ;
2469   }
2470 }
2471
2472 JNIEXPORT void JNICALL
2473 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
2474   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2475 {
2476   guestfs_h *g = (guestfs_h *) (long) jg;
2477   int r;
2478   const char *fstype;
2479   const char *device;
2480
2481   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2482   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2483   r = guestfs_mkfs (g, fstype, device);
2484   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2485   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2486   if (r == -1) {
2487     throw_exception (env, guestfs_last_error (g));
2488     return ;
2489   }
2490 }
2491
2492 JNIEXPORT void JNICALL
2493 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
2494   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
2495 {
2496   guestfs_h *g = (guestfs_h *) (long) jg;
2497   int r;
2498   const char *device;
2499   int cyls;
2500   int heads;
2501   int sectors;
2502   int lines_len;
2503   const char **lines;
2504   int i;
2505
2506   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2507   cyls = jcyls;
2508   heads = jheads;
2509   sectors = jsectors;
2510   lines_len = (*env)->GetArrayLength (env, jlines);
2511   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
2512   for (i = 0; i < lines_len; ++i) {
2513     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2514     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
2515   }
2516   lines[lines_len] = NULL;
2517   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2518   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2519   for (i = 0; i < lines_len; ++i) {
2520     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2521     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
2522   }
2523   free (lines);
2524   if (r == -1) {
2525     throw_exception (env, guestfs_last_error (g));
2526     return ;
2527   }
2528 }
2529
2530 JNIEXPORT void JNICALL
2531 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
2532   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
2533 {
2534   guestfs_h *g = (guestfs_h *) (long) jg;
2535   int r;
2536   const char *path;
2537   const char *content;
2538   int size;
2539
2540   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2541   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
2542   size = jsize;
2543   r = guestfs_write_file (g, path, content, size);
2544   (*env)->ReleaseStringUTFChars (env, jpath, path);
2545   (*env)->ReleaseStringUTFChars (env, jcontent, content);
2546   if (r == -1) {
2547     throw_exception (env, guestfs_last_error (g));
2548     return ;
2549   }
2550 }
2551
2552 JNIEXPORT void JNICALL
2553 Java_com_redhat_et_libguestfs_GuestFS__1umount
2554   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
2555 {
2556   guestfs_h *g = (guestfs_h *) (long) jg;
2557   int r;
2558   const char *pathordevice;
2559
2560   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
2561   r = guestfs_umount (g, pathordevice);
2562   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
2563   if (r == -1) {
2564     throw_exception (env, guestfs_last_error (g));
2565     return ;
2566   }
2567 }
2568
2569 JNIEXPORT jobjectArray JNICALL
2570 Java_com_redhat_et_libguestfs_GuestFS__1mounts
2571   (JNIEnv *env, jobject obj, jlong jg)
2572 {
2573   guestfs_h *g = (guestfs_h *) (long) jg;
2574   jobjectArray jr;
2575   int r_len;
2576   jclass cl;
2577   jstring jstr;
2578   char **r;
2579   int i;
2580
2581   r = guestfs_mounts (g);
2582   if (r == NULL) {
2583     throw_exception (env, guestfs_last_error (g));
2584     return NULL;
2585   }
2586   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2587   cl = (*env)->FindClass (env, "java/lang/String");
2588   jstr = (*env)->NewStringUTF (env, "");
2589   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2590   for (i = 0; i < r_len; ++i) {
2591     jstr = (*env)->NewStringUTF (env, r[i]);
2592     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2593     free (r[i]);
2594   }
2595   free (r);
2596   return jr;
2597 }
2598
2599 JNIEXPORT void JNICALL
2600 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
2601   (JNIEnv *env, jobject obj, jlong jg)
2602 {
2603   guestfs_h *g = (guestfs_h *) (long) jg;
2604   int r;
2605
2606   r = guestfs_umount_all (g);
2607   if (r == -1) {
2608     throw_exception (env, guestfs_last_error (g));
2609     return ;
2610   }
2611 }
2612
2613 JNIEXPORT void JNICALL
2614 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
2615   (JNIEnv *env, jobject obj, jlong jg)
2616 {
2617   guestfs_h *g = (guestfs_h *) (long) jg;
2618   int r;
2619
2620   r = guestfs_lvm_remove_all (g);
2621   if (r == -1) {
2622     throw_exception (env, guestfs_last_error (g));
2623     return ;
2624   }
2625 }
2626
2627 JNIEXPORT jstring JNICALL
2628 Java_com_redhat_et_libguestfs_GuestFS__1file
2629   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2630 {
2631   guestfs_h *g = (guestfs_h *) (long) jg;
2632   jstring jr;
2633   char *r;
2634   const char *path;
2635
2636   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2637   r = guestfs_file (g, path);
2638   (*env)->ReleaseStringUTFChars (env, jpath, path);
2639   if (r == NULL) {
2640     throw_exception (env, guestfs_last_error (g));
2641     return NULL;
2642   }
2643   jr = (*env)->NewStringUTF (env, r);
2644   free (r);
2645   return jr;
2646 }
2647
2648 JNIEXPORT jstring JNICALL
2649 Java_com_redhat_et_libguestfs_GuestFS__1command
2650   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2651 {
2652   guestfs_h *g = (guestfs_h *) (long) jg;
2653   jstring jr;
2654   char *r;
2655   int arguments_len;
2656   const char **arguments;
2657   int i;
2658
2659   arguments_len = (*env)->GetArrayLength (env, jarguments);
2660   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2661   for (i = 0; i < arguments_len; ++i) {
2662     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2663     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2664   }
2665   arguments[arguments_len] = NULL;
2666   r = guestfs_command (g, arguments);
2667   for (i = 0; i < arguments_len; ++i) {
2668     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2669     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2670   }
2671   free (arguments);
2672   if (r == NULL) {
2673     throw_exception (env, guestfs_last_error (g));
2674     return NULL;
2675   }
2676   jr = (*env)->NewStringUTF (env, r);
2677   free (r);
2678   return jr;
2679 }
2680
2681 JNIEXPORT jobjectArray JNICALL
2682 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
2683   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2684 {
2685   guestfs_h *g = (guestfs_h *) (long) jg;
2686   jobjectArray jr;
2687   int r_len;
2688   jclass cl;
2689   jstring jstr;
2690   char **r;
2691   int arguments_len;
2692   const char **arguments;
2693   int i;
2694
2695   arguments_len = (*env)->GetArrayLength (env, jarguments);
2696   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2697   for (i = 0; i < arguments_len; ++i) {
2698     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2699     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2700   }
2701   arguments[arguments_len] = NULL;
2702   r = guestfs_command_lines (g, arguments);
2703   for (i = 0; i < arguments_len; ++i) {
2704     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2705     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2706   }
2707   free (arguments);
2708   if (r == NULL) {
2709     throw_exception (env, guestfs_last_error (g));
2710     return NULL;
2711   }
2712   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2713   cl = (*env)->FindClass (env, "java/lang/String");
2714   jstr = (*env)->NewStringUTF (env, "");
2715   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2716   for (i = 0; i < r_len; ++i) {
2717     jstr = (*env)->NewStringUTF (env, r[i]);
2718     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2719     free (r[i]);
2720   }
2721   free (r);
2722   return jr;
2723 }
2724
2725 JNIEXPORT jobject JNICALL
2726 Java_com_redhat_et_libguestfs_GuestFS__1stat
2727   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2728 {
2729   guestfs_h *g = (guestfs_h *) (long) jg;
2730   jobject jr;
2731   jclass cl;
2732   jfieldID fl;
2733   struct guestfs_stat *r;
2734   const char *path;
2735
2736   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2737   r = guestfs_stat (g, path);
2738   (*env)->ReleaseStringUTFChars (env, jpath, path);
2739   if (r == NULL) {
2740     throw_exception (env, guestfs_last_error (g));
2741     return NULL;
2742   }
2743   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2744   jr = (*env)->AllocObject (env, cl);
2745   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2746   (*env)->SetLongField (env, jr, fl, r->dev);
2747   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2748   (*env)->SetLongField (env, jr, fl, r->ino);
2749   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2750   (*env)->SetLongField (env, jr, fl, r->mode);
2751   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2752   (*env)->SetLongField (env, jr, fl, r->nlink);
2753   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2754   (*env)->SetLongField (env, jr, fl, r->uid);
2755   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2756   (*env)->SetLongField (env, jr, fl, r->gid);
2757   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2758   (*env)->SetLongField (env, jr, fl, r->rdev);
2759   fl = (*env)->GetFieldID (env, cl, "size", "J");
2760   (*env)->SetLongField (env, jr, fl, r->size);
2761   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2762   (*env)->SetLongField (env, jr, fl, r->blksize);
2763   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2764   (*env)->SetLongField (env, jr, fl, r->blocks);
2765   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2766   (*env)->SetLongField (env, jr, fl, r->atime);
2767   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2768   (*env)->SetLongField (env, jr, fl, r->mtime);
2769   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2770   (*env)->SetLongField (env, jr, fl, r->ctime);
2771   free (r);
2772   return jr;
2773 }
2774
2775 JNIEXPORT jobject JNICALL
2776 Java_com_redhat_et_libguestfs_GuestFS__1lstat
2777   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2778 {
2779   guestfs_h *g = (guestfs_h *) (long) jg;
2780   jobject jr;
2781   jclass cl;
2782   jfieldID fl;
2783   struct guestfs_stat *r;
2784   const char *path;
2785
2786   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2787   r = guestfs_lstat (g, path);
2788   (*env)->ReleaseStringUTFChars (env, jpath, path);
2789   if (r == NULL) {
2790     throw_exception (env, guestfs_last_error (g));
2791     return NULL;
2792   }
2793   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2794   jr = (*env)->AllocObject (env, cl);
2795   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2796   (*env)->SetLongField (env, jr, fl, r->dev);
2797   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2798   (*env)->SetLongField (env, jr, fl, r->ino);
2799   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2800   (*env)->SetLongField (env, jr, fl, r->mode);
2801   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2802   (*env)->SetLongField (env, jr, fl, r->nlink);
2803   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2804   (*env)->SetLongField (env, jr, fl, r->uid);
2805   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2806   (*env)->SetLongField (env, jr, fl, r->gid);
2807   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2808   (*env)->SetLongField (env, jr, fl, r->rdev);
2809   fl = (*env)->GetFieldID (env, cl, "size", "J");
2810   (*env)->SetLongField (env, jr, fl, r->size);
2811   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2812   (*env)->SetLongField (env, jr, fl, r->blksize);
2813   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2814   (*env)->SetLongField (env, jr, fl, r->blocks);
2815   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2816   (*env)->SetLongField (env, jr, fl, r->atime);
2817   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2818   (*env)->SetLongField (env, jr, fl, r->mtime);
2819   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2820   (*env)->SetLongField (env, jr, fl, r->ctime);
2821   free (r);
2822   return jr;
2823 }
2824
2825 JNIEXPORT jobject JNICALL
2826 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
2827   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2828 {
2829   guestfs_h *g = (guestfs_h *) (long) jg;
2830   jobject jr;
2831   jclass cl;
2832   jfieldID fl;
2833   struct guestfs_statvfs *r;
2834   const char *path;
2835
2836   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2837   r = guestfs_statvfs (g, path);
2838   (*env)->ReleaseStringUTFChars (env, jpath, path);
2839   if (r == NULL) {
2840     throw_exception (env, guestfs_last_error (g));
2841     return NULL;
2842   }
2843   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
2844   jr = (*env)->AllocObject (env, cl);
2845   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
2846   (*env)->SetLongField (env, jr, fl, r->bsize);
2847   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
2848   (*env)->SetLongField (env, jr, fl, r->frsize);
2849   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2850   (*env)->SetLongField (env, jr, fl, r->blocks);
2851   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
2852   (*env)->SetLongField (env, jr, fl, r->bfree);
2853   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
2854   (*env)->SetLongField (env, jr, fl, r->bavail);
2855   fl = (*env)->GetFieldID (env, cl, "files", "J");
2856   (*env)->SetLongField (env, jr, fl, r->files);
2857   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
2858   (*env)->SetLongField (env, jr, fl, r->ffree);
2859   fl = (*env)->GetFieldID (env, cl, "favail", "J");
2860   (*env)->SetLongField (env, jr, fl, r->favail);
2861   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
2862   (*env)->SetLongField (env, jr, fl, r->fsid);
2863   fl = (*env)->GetFieldID (env, cl, "flag", "J");
2864   (*env)->SetLongField (env, jr, fl, r->flag);
2865   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
2866   (*env)->SetLongField (env, jr, fl, r->namemax);
2867   free (r);
2868   return jr;
2869 }
2870
2871 JNIEXPORT jobject JNICALL
2872 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
2873   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2874 {
2875   guestfs_h *g = (guestfs_h *) (long) jg;
2876   char **r;
2877   const char *device;
2878
2879   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2880   r = guestfs_tune2fs_l (g, device);
2881   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2882   if (r == NULL) {
2883     throw_exception (env, guestfs_last_error (g));
2884     return NULL;
2885   }
2886   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
2887   return NULL;
2888 }
2889
2890 JNIEXPORT void JNICALL
2891 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
2892   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2893 {
2894   guestfs_h *g = (guestfs_h *) (long) jg;
2895   int r;
2896   const char *device;
2897
2898   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2899   r = guestfs_blockdev_setro (g, device);
2900   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2901   if (r == -1) {
2902     throw_exception (env, guestfs_last_error (g));
2903     return ;
2904   }
2905 }
2906
2907 JNIEXPORT void JNICALL
2908 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
2909   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2910 {
2911   guestfs_h *g = (guestfs_h *) (long) jg;
2912   int r;
2913   const char *device;
2914
2915   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2916   r = guestfs_blockdev_setrw (g, device);
2917   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2918   if (r == -1) {
2919     throw_exception (env, guestfs_last_error (g));
2920     return ;
2921   }
2922 }
2923
2924 JNIEXPORT jboolean JNICALL
2925 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
2926   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2927 {
2928   guestfs_h *g = (guestfs_h *) (long) jg;
2929   int r;
2930   const char *device;
2931
2932   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2933   r = guestfs_blockdev_getro (g, device);
2934   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2935   if (r == -1) {
2936     throw_exception (env, guestfs_last_error (g));
2937     return 0;
2938   }
2939   return (jboolean) r;
2940 }
2941
2942 JNIEXPORT jint JNICALL
2943 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
2944   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2945 {
2946   guestfs_h *g = (guestfs_h *) (long) jg;
2947   int r;
2948   const char *device;
2949
2950   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2951   r = guestfs_blockdev_getss (g, device);
2952   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2953   if (r == -1) {
2954     throw_exception (env, guestfs_last_error (g));
2955     return 0;
2956   }
2957   return (jint) r;
2958 }
2959
2960 JNIEXPORT jint JNICALL
2961 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
2962   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2963 {
2964   guestfs_h *g = (guestfs_h *) (long) jg;
2965   int r;
2966   const char *device;
2967
2968   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2969   r = guestfs_blockdev_getbsz (g, device);
2970   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2971   if (r == -1) {
2972     throw_exception (env, guestfs_last_error (g));
2973     return 0;
2974   }
2975   return (jint) r;
2976 }
2977
2978 JNIEXPORT void JNICALL
2979 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
2980   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
2981 {
2982   guestfs_h *g = (guestfs_h *) (long) jg;
2983   int r;
2984   const char *device;
2985   int blocksize;
2986
2987   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2988   blocksize = jblocksize;
2989   r = guestfs_blockdev_setbsz (g, device, blocksize);
2990   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2991   if (r == -1) {
2992     throw_exception (env, guestfs_last_error (g));
2993     return ;
2994   }
2995 }
2996
2997 JNIEXPORT jlong JNICALL
2998 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
2999   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3000 {
3001   guestfs_h *g = (guestfs_h *) (long) jg;
3002   int64_t r;
3003   const char *device;
3004
3005   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3006   r = guestfs_blockdev_getsz (g, device);
3007   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3008   if (r == -1) {
3009     throw_exception (env, guestfs_last_error (g));
3010     return 0;
3011   }
3012   return (jlong) r;
3013 }
3014
3015 JNIEXPORT jlong JNICALL
3016 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
3017   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3018 {
3019   guestfs_h *g = (guestfs_h *) (long) jg;
3020   int64_t r;
3021   const char *device;
3022
3023   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3024   r = guestfs_blockdev_getsize64 (g, device);
3025   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3026   if (r == -1) {
3027     throw_exception (env, guestfs_last_error (g));
3028     return 0;
3029   }
3030   return (jlong) r;
3031 }
3032
3033 JNIEXPORT void JNICALL
3034 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
3035   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3036 {
3037   guestfs_h *g = (guestfs_h *) (long) jg;
3038   int r;
3039   const char *device;
3040
3041   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3042   r = guestfs_blockdev_flushbufs (g, device);
3043   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3044   if (r == -1) {
3045     throw_exception (env, guestfs_last_error (g));
3046     return ;
3047   }
3048 }
3049
3050 JNIEXPORT void JNICALL
3051 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
3052   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3053 {
3054   guestfs_h *g = (guestfs_h *) (long) jg;
3055   int r;
3056   const char *device;
3057
3058   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3059   r = guestfs_blockdev_rereadpt (g, device);
3060   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3061   if (r == -1) {
3062     throw_exception (env, guestfs_last_error (g));
3063     return ;
3064   }
3065 }
3066
3067 JNIEXPORT void JNICALL
3068 Java_com_redhat_et_libguestfs_GuestFS__1upload
3069   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
3070 {
3071   guestfs_h *g = (guestfs_h *) (long) jg;
3072   int r;
3073   const char *filename;
3074   const char *remotefilename;
3075
3076   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3077   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3078   r = guestfs_upload (g, filename, remotefilename);
3079   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3080   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3081   if (r == -1) {
3082     throw_exception (env, guestfs_last_error (g));
3083     return ;
3084   }
3085 }
3086
3087 JNIEXPORT void JNICALL
3088 Java_com_redhat_et_libguestfs_GuestFS__1download
3089   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
3090 {
3091   guestfs_h *g = (guestfs_h *) (long) jg;
3092   int r;
3093   const char *remotefilename;
3094   const char *filename;
3095
3096   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3097   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3098   r = guestfs_download (g, remotefilename, filename);
3099   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3100   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3101   if (r == -1) {
3102     throw_exception (env, guestfs_last_error (g));
3103     return ;
3104   }
3105 }
3106
3107 JNIEXPORT jstring JNICALL
3108 Java_com_redhat_et_libguestfs_GuestFS__1checksum
3109   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
3110 {
3111   guestfs_h *g = (guestfs_h *) (long) jg;
3112   jstring jr;
3113   char *r;
3114   const char *csumtype;
3115   const char *path;
3116
3117   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
3118   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3119   r = guestfs_checksum (g, csumtype, path);
3120   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
3121   (*env)->ReleaseStringUTFChars (env, jpath, path);
3122   if (r == NULL) {
3123     throw_exception (env, guestfs_last_error (g));
3124     return NULL;
3125   }
3126   jr = (*env)->NewStringUTF (env, r);
3127   free (r);
3128   return jr;
3129 }
3130
3131 JNIEXPORT void JNICALL
3132 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
3133   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
3134 {
3135   guestfs_h *g = (guestfs_h *) (long) jg;
3136   int r;
3137   const char *tarfile;
3138   const char *directory;
3139
3140   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3141   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3142   r = guestfs_tar_in (g, tarfile, directory);
3143   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3144   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3145   if (r == -1) {
3146     throw_exception (env, guestfs_last_error (g));
3147     return ;
3148   }
3149 }
3150
3151 JNIEXPORT void JNICALL
3152 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
3153   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
3154 {
3155   guestfs_h *g = (guestfs_h *) (long) jg;
3156   int r;
3157   const char *directory;
3158   const char *tarfile;
3159
3160   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3161   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3162   r = guestfs_tar_out (g, directory, tarfile);
3163   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3164   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3165   if (r == -1) {
3166     throw_exception (env, guestfs_last_error (g));
3167     return ;
3168   }
3169 }
3170
3171 JNIEXPORT void JNICALL
3172 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
3173   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
3174 {
3175   guestfs_h *g = (guestfs_h *) (long) jg;
3176   int r;
3177   const char *tarball;
3178   const char *directory;
3179
3180   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3181   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3182   r = guestfs_tgz_in (g, tarball, directory);
3183   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3184   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3185   if (r == -1) {
3186     throw_exception (env, guestfs_last_error (g));
3187     return ;
3188   }
3189 }
3190
3191 JNIEXPORT void JNICALL
3192 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
3193   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
3194 {
3195   guestfs_h *g = (guestfs_h *) (long) jg;
3196   int r;
3197   const char *directory;
3198   const char *tarball;
3199
3200   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3201   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3202   r = guestfs_tgz_out (g, directory, tarball);
3203   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3204   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3205   if (r == -1) {
3206     throw_exception (env, guestfs_last_error (g));
3207     return ;
3208   }
3209 }
3210
3211 JNIEXPORT void JNICALL
3212 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
3213   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
3214 {
3215   guestfs_h *g = (guestfs_h *) (long) jg;
3216   int r;
3217   const char *device;
3218   const char *mountpoint;
3219
3220   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3221   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3222   r = guestfs_mount_ro (g, device, mountpoint);
3223   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3224   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3225   if (r == -1) {
3226     throw_exception (env, guestfs_last_error (g));
3227     return ;
3228   }
3229 }
3230
3231 JNIEXPORT void JNICALL
3232 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
3233   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
3234 {
3235   guestfs_h *g = (guestfs_h *) (long) jg;
3236   int r;
3237   const char *options;
3238   const char *device;
3239   const char *mountpoint;
3240
3241   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3242   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3243   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3244   r = guestfs_mount_options (g, options, device, mountpoint);
3245   (*env)->ReleaseStringUTFChars (env, joptions, options);
3246   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3247   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3248   if (r == -1) {
3249     throw_exception (env, guestfs_last_error (g));
3250     return ;
3251   }
3252 }
3253
3254 JNIEXPORT void JNICALL
3255 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
3256   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
3257 {
3258   guestfs_h *g = (guestfs_h *) (long) jg;
3259   int r;
3260   const char *options;
3261   const char *vfstype;
3262   const char *device;
3263   const char *mountpoint;
3264
3265   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3266   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
3267   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3268   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3269   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3270   (*env)->ReleaseStringUTFChars (env, joptions, options);
3271   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
3272   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3273   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3274   if (r == -1) {
3275     throw_exception (env, guestfs_last_error (g));
3276     return ;
3277   }
3278 }
3279
3280 JNIEXPORT jstring JNICALL
3281 Java_com_redhat_et_libguestfs_GuestFS__1debug
3282   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
3283 {
3284   guestfs_h *g = (guestfs_h *) (long) jg;
3285   jstring jr;
3286   char *r;
3287   const char *subcmd;
3288   int extraargs_len;
3289   const char **extraargs;
3290   int i;
3291
3292   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
3293   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
3294   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
3295   for (i = 0; i < extraargs_len; ++i) {
3296     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3297     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
3298   }
3299   extraargs[extraargs_len] = NULL;
3300   r = guestfs_debug (g, subcmd, extraargs);
3301   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
3302   for (i = 0; i < extraargs_len; ++i) {
3303     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3304     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
3305   }
3306   free (extraargs);
3307   if (r == NULL) {
3308     throw_exception (env, guestfs_last_error (g));
3309     return NULL;
3310   }
3311   jr = (*env)->NewStringUTF (env, r);
3312   free (r);
3313   return jr;
3314 }
3315
3316 JNIEXPORT void JNICALL
3317 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
3318   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3319 {
3320   guestfs_h *g = (guestfs_h *) (long) jg;
3321   int r;
3322   const char *device;
3323
3324   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3325   r = guestfs_lvremove (g, device);
3326   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3327   if (r == -1) {
3328     throw_exception (env, guestfs_last_error (g));
3329     return ;
3330   }
3331 }
3332
3333 JNIEXPORT void JNICALL
3334 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
3335   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
3336 {
3337   guestfs_h *g = (guestfs_h *) (long) jg;
3338   int r;
3339   const char *vgname;
3340
3341   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
3342   r = guestfs_vgremove (g, vgname);
3343   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
3344   if (r == -1) {
3345     throw_exception (env, guestfs_last_error (g));
3346     return ;
3347   }
3348 }
3349
3350 JNIEXPORT void JNICALL
3351 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
3352   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3353 {
3354   guestfs_h *g = (guestfs_h *) (long) jg;
3355   int r;
3356   const char *device;
3357
3358   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3359   r = guestfs_pvremove (g, device);
3360   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3361   if (r == -1) {
3362     throw_exception (env, guestfs_last_error (g));
3363     return ;
3364   }
3365 }
3366
3367 JNIEXPORT void JNICALL
3368 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
3369   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
3370 {
3371   guestfs_h *g = (guestfs_h *) (long) jg;
3372   int r;
3373   const char *device;
3374   const char *label;
3375
3376   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3377   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
3378   r = guestfs_set_e2label (g, device, label);
3379   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3380   (*env)->ReleaseStringUTFChars (env, jlabel, label);
3381   if (r == -1) {
3382     throw_exception (env, guestfs_last_error (g));
3383     return ;
3384   }
3385 }
3386
3387 JNIEXPORT jstring JNICALL
3388 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
3389   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3390 {
3391   guestfs_h *g = (guestfs_h *) (long) jg;
3392   jstring jr;
3393   char *r;
3394   const char *device;
3395
3396   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3397   r = guestfs_get_e2label (g, device);
3398   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3399   if (r == NULL) {
3400     throw_exception (env, guestfs_last_error (g));
3401     return NULL;
3402   }
3403   jr = (*env)->NewStringUTF (env, r);
3404   free (r);
3405   return jr;
3406 }
3407
3408 JNIEXPORT void JNICALL
3409 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
3410   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
3411 {
3412   guestfs_h *g = (guestfs_h *) (long) jg;
3413   int r;
3414   const char *device;
3415   const char *uuid;
3416
3417   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3418   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
3419   r = guestfs_set_e2uuid (g, device, uuid);
3420   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3421   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
3422   if (r == -1) {
3423     throw_exception (env, guestfs_last_error (g));
3424     return ;
3425   }
3426 }
3427
3428 JNIEXPORT jstring JNICALL
3429 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
3430   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3431 {
3432   guestfs_h *g = (guestfs_h *) (long) jg;
3433   jstring jr;
3434   char *r;
3435   const char *device;
3436
3437   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3438   r = guestfs_get_e2uuid (g, device);
3439   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3440   if (r == NULL) {
3441     throw_exception (env, guestfs_last_error (g));
3442     return NULL;
3443   }
3444   jr = (*env)->NewStringUTF (env, r);
3445   free (r);
3446   return jr;
3447 }
3448
3449 JNIEXPORT jint JNICALL
3450 Java_com_redhat_et_libguestfs_GuestFS__1fsck
3451   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
3452 {
3453   guestfs_h *g = (guestfs_h *) (long) jg;
3454   int r;
3455   const char *fstype;
3456   const char *device;
3457
3458   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
3459   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3460   r = guestfs_fsck (g, fstype, device);
3461   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
3462   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3463   if (r == -1) {
3464     throw_exception (env, guestfs_last_error (g));
3465     return 0;
3466   }
3467   return (jint) r;
3468 }
3469
3470 JNIEXPORT void JNICALL
3471 Java_com_redhat_et_libguestfs_GuestFS__1zero
3472   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3473 {
3474   guestfs_h *g = (guestfs_h *) (long) jg;
3475   int r;
3476   const char *device;
3477
3478   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3479   r = guestfs_zero (g, device);
3480   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3481   if (r == -1) {
3482     throw_exception (env, guestfs_last_error (g));
3483     return ;
3484   }
3485 }
3486
3487 JNIEXPORT void JNICALL
3488 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
3489   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
3490 {
3491   guestfs_h *g = (guestfs_h *) (long) jg;
3492   int r;
3493   const char *root;
3494   const char *device;
3495
3496   root = (*env)->GetStringUTFChars (env, jroot, NULL);
3497   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3498   r = guestfs_grub_install (g, root, device);
3499   (*env)->ReleaseStringUTFChars (env, jroot, root);
3500   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3501   if (r == -1) {
3502     throw_exception (env, guestfs_last_error (g));
3503     return ;
3504   }
3505 }
3506
3507 JNIEXPORT void JNICALL
3508 Java_com_redhat_et_libguestfs_GuestFS__1cp
3509   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3510 {
3511   guestfs_h *g = (guestfs_h *) (long) jg;
3512   int r;
3513   const char *src;
3514   const char *dest;
3515
3516   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3517   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3518   r = guestfs_cp (g, src, dest);
3519   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3520   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3521   if (r == -1) {
3522     throw_exception (env, guestfs_last_error (g));
3523     return ;
3524   }
3525 }
3526
3527 JNIEXPORT void JNICALL
3528 Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
3529   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3530 {
3531   guestfs_h *g = (guestfs_h *) (long) jg;
3532   int r;
3533   const char *src;
3534   const char *dest;
3535
3536   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3537   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3538   r = guestfs_cp_a (g, src, dest);
3539   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3540   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3541   if (r == -1) {
3542     throw_exception (env, guestfs_last_error (g));
3543     return ;
3544   }
3545 }
3546
3547 JNIEXPORT void JNICALL
3548 Java_com_redhat_et_libguestfs_GuestFS__1mv
3549   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3550 {
3551   guestfs_h *g = (guestfs_h *) (long) jg;
3552   int r;
3553   const char *src;
3554   const char *dest;
3555
3556   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3557   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3558   r = guestfs_mv (g, src, dest);
3559   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3560   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3561   if (r == -1) {
3562     throw_exception (env, guestfs_last_error (g));
3563     return ;
3564   }
3565 }
3566
3567 JNIEXPORT void JNICALL
3568 Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
3569   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
3570 {
3571   guestfs_h *g = (guestfs_h *) (long) jg;
3572   int r;
3573   int whattodrop;
3574
3575   whattodrop = jwhattodrop;
3576   r = guestfs_drop_caches (g, whattodrop);
3577   if (r == -1) {
3578     throw_exception (env, guestfs_last_error (g));
3579     return ;
3580   }
3581 }
3582
3583 JNIEXPORT jstring JNICALL
3584 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
3585   (JNIEnv *env, jobject obj, jlong jg)
3586 {
3587   guestfs_h *g = (guestfs_h *) (long) jg;
3588   jstring jr;
3589   char *r;
3590
3591   r = guestfs_dmesg (g);
3592   if (r == NULL) {
3593     throw_exception (env, guestfs_last_error (g));
3594     return NULL;
3595   }
3596   jr = (*env)->NewStringUTF (env, r);
3597   free (r);
3598   return jr;
3599 }
3600
3601 JNIEXPORT void JNICALL
3602 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
3603   (JNIEnv *env, jobject obj, jlong jg)
3604 {
3605   guestfs_h *g = (guestfs_h *) (long) jg;
3606   int r;
3607
3608   r = guestfs_ping_daemon (g);
3609   if (r == -1) {
3610     throw_exception (env, guestfs_last_error (g));
3611     return ;
3612   }
3613 }
3614
3615 JNIEXPORT jboolean JNICALL
3616 Java_com_redhat_et_libguestfs_GuestFS__1equal
3617   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
3618 {
3619   guestfs_h *g = (guestfs_h *) (long) jg;
3620   int r;
3621   const char *file1;
3622   const char *file2;
3623
3624   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
3625   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
3626   r = guestfs_equal (g, file1, file2);
3627   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
3628   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
3629   if (r == -1) {
3630     throw_exception (env, guestfs_last_error (g));
3631     return 0;
3632   }
3633   return (jboolean) r;
3634 }
3635
3636 JNIEXPORT jobjectArray JNICALL
3637 Java_com_redhat_et_libguestfs_GuestFS__1strings
3638   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3639 {
3640   guestfs_h *g = (guestfs_h *) (long) jg;
3641   jobjectArray jr;
3642   int r_len;
3643   jclass cl;
3644   jstring jstr;
3645   char **r;
3646   const char *path;
3647   int i;
3648
3649   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3650   r = guestfs_strings (g, path);
3651   (*env)->ReleaseStringUTFChars (env, jpath, path);
3652   if (r == NULL) {
3653     throw_exception (env, guestfs_last_error (g));
3654     return NULL;
3655   }
3656   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3657   cl = (*env)->FindClass (env, "java/lang/String");
3658   jstr = (*env)->NewStringUTF (env, "");
3659   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3660   for (i = 0; i < r_len; ++i) {
3661     jstr = (*env)->NewStringUTF (env, r[i]);
3662     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3663     free (r[i]);
3664   }
3665   free (r);
3666   return jr;
3667 }
3668
3669 JNIEXPORT jobjectArray JNICALL
3670 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
3671   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
3672 {
3673   guestfs_h *g = (guestfs_h *) (long) jg;
3674   jobjectArray jr;
3675   int r_len;
3676   jclass cl;
3677   jstring jstr;
3678   char **r;
3679   const char *encoding;
3680   const char *path;
3681   int i;
3682
3683   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
3684   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3685   r = guestfs_strings_e (g, encoding, path);
3686   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
3687   (*env)->ReleaseStringUTFChars (env, jpath, path);
3688   if (r == NULL) {
3689     throw_exception (env, guestfs_last_error (g));
3690     return NULL;
3691   }
3692   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3693   cl = (*env)->FindClass (env, "java/lang/String");
3694   jstr = (*env)->NewStringUTF (env, "");
3695   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3696   for (i = 0; i < r_len; ++i) {
3697     jstr = (*env)->NewStringUTF (env, r[i]);
3698     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3699     free (r[i]);
3700   }
3701   free (r);
3702   return jr;
3703 }
3704
3705 JNIEXPORT jstring JNICALL
3706 Java_com_redhat_et_libguestfs_GuestFS__1hexdump
3707   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3708 {
3709   guestfs_h *g = (guestfs_h *) (long) jg;
3710   jstring jr;
3711   char *r;
3712   const char *path;
3713
3714   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3715   r = guestfs_hexdump (g, path);
3716   (*env)->ReleaseStringUTFChars (env, jpath, path);
3717   if (r == NULL) {
3718     throw_exception (env, guestfs_last_error (g));
3719     return NULL;
3720   }
3721   jr = (*env)->NewStringUTF (env, r);
3722   free (r);
3723   return jr;
3724 }
3725
3726 JNIEXPORT void JNICALL
3727 Java_com_redhat_et_libguestfs_GuestFS__1zerofree
3728   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3729 {
3730   guestfs_h *g = (guestfs_h *) (long) jg;
3731   int r;
3732   const char *device;
3733
3734   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3735   r = guestfs_zerofree (g, device);
3736   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3737   if (r == -1) {
3738     throw_exception (env, guestfs_last_error (g));
3739     return ;
3740   }
3741 }
3742
3743 JNIEXPORT void JNICALL
3744 Java_com_redhat_et_libguestfs_GuestFS__1pvresize
3745   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3746 {
3747   guestfs_h *g = (guestfs_h *) (long) jg;
3748   int r;
3749   const char *device;
3750
3751   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3752   r = guestfs_pvresize (g, device);
3753   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3754   if (r == -1) {
3755     throw_exception (env, guestfs_last_error (g));
3756     return ;
3757   }
3758 }
3759
3760 JNIEXPORT void JNICALL
3761 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1N
3762   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jpartnum, jint jcyls, jint jheads, jint jsectors, jstring jline)
3763 {
3764   guestfs_h *g = (guestfs_h *) (long) jg;
3765   int r;
3766   const char *device;
3767   int partnum;
3768   int cyls;
3769   int heads;
3770   int sectors;
3771   const char *line;
3772
3773   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3774   partnum = jpartnum;
3775   cyls = jcyls;
3776   heads = jheads;
3777   sectors = jsectors;
3778   line = (*env)->GetStringUTFChars (env, jline, NULL);
3779   r = guestfs_sfdisk_N (g, device, partnum, cyls, heads, sectors, line);
3780   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3781   (*env)->ReleaseStringUTFChars (env, jline, line);
3782   if (r == -1) {
3783     throw_exception (env, guestfs_last_error (g));
3784     return ;
3785   }
3786 }
3787
3788 JNIEXPORT jstring JNICALL
3789 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1l
3790   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3791 {
3792   guestfs_h *g = (guestfs_h *) (long) jg;
3793   jstring jr;
3794   char *r;
3795   const char *device;
3796
3797   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3798   r = guestfs_sfdisk_l (g, device);
3799   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3800   if (r == NULL) {
3801     throw_exception (env, guestfs_last_error (g));
3802     return NULL;
3803   }
3804   jr = (*env)->NewStringUTF (env, r);
3805   free (r);
3806   return jr;
3807 }
3808
3809 JNIEXPORT jstring JNICALL
3810 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1kernel_1geometry
3811   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3812 {
3813   guestfs_h *g = (guestfs_h *) (long) jg;
3814   jstring jr;
3815   char *r;
3816   const char *device;
3817
3818   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3819   r = guestfs_sfdisk_kernel_geometry (g, device);
3820   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3821   if (r == NULL) {
3822     throw_exception (env, guestfs_last_error (g));
3823     return NULL;
3824   }
3825   jr = (*env)->NewStringUTF (env, r);
3826   free (r);
3827   return jr;
3828 }
3829
3830 JNIEXPORT jstring JNICALL
3831 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk_1disk_1geometry
3832   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3833 {
3834   guestfs_h *g = (guestfs_h *) (long) jg;
3835   jstring jr;
3836   char *r;
3837   const char *device;
3838
3839   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3840   r = guestfs_sfdisk_disk_geometry (g, device);
3841   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3842   if (r == NULL) {
3843     throw_exception (env, guestfs_last_error (g));
3844     return NULL;
3845   }
3846   jr = (*env)->NewStringUTF (env, r);
3847   free (r);
3848   return jr;
3849 }
3850
3851 JNIEXPORT void JNICALL
3852 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate_1all
3853   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate)
3854 {
3855   guestfs_h *g = (guestfs_h *) (long) jg;
3856   int r;
3857   int activate;
3858
3859   activate = jactivate;
3860   r = guestfs_vg_activate_all (g, activate);
3861   if (r == -1) {
3862     throw_exception (env, guestfs_last_error (g));
3863     return ;
3864   }
3865 }
3866
3867 JNIEXPORT void JNICALL
3868 Java_com_redhat_et_libguestfs_GuestFS__1vg_1activate
3869   (JNIEnv *env, jobject obj, jlong jg, jboolean jactivate, jobjectArray jvolgroups)
3870 {
3871   guestfs_h *g = (guestfs_h *) (long) jg;
3872   int r;
3873   int activate;
3874   int volgroups_len;
3875   const char **volgroups;
3876   int i;
3877
3878   activate = jactivate;
3879   volgroups_len = (*env)->GetArrayLength (env, jvolgroups);
3880   volgroups = guestfs_safe_malloc (g, sizeof (char *) * (volgroups_len+1));
3881   for (i = 0; i < volgroups_len; ++i) {
3882     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3883     volgroups[i] = (*env)->GetStringUTFChars (env, o, NULL);
3884   }
3885   volgroups[volgroups_len] = NULL;
3886   r = guestfs_vg_activate (g, activate, volgroups);
3887   for (i = 0; i < volgroups_len; ++i) {
3888     jobject o = (*env)->GetObjectArrayElement (env, jvolgroups, i);
3889     (*env)->ReleaseStringUTFChars (env, o, volgroups[i]);
3890   }
3891   free (volgroups);
3892   if (r == -1) {
3893     throw_exception (env, guestfs_last_error (g));
3894     return ;
3895   }
3896 }
3897
3898 JNIEXPORT void JNICALL
3899 Java_com_redhat_et_libguestfs_GuestFS__1lvresize
3900   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jmbytes)
3901 {
3902   guestfs_h *g = (guestfs_h *) (long) jg;
3903   int r;
3904   const char *device;
3905   int mbytes;
3906
3907   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3908   mbytes = jmbytes;
3909   r = guestfs_lvresize (g, device, mbytes);
3910   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3911   if (r == -1) {
3912     throw_exception (env, guestfs_last_error (g));
3913     return ;
3914   }
3915 }
3916
3917 JNIEXPORT void JNICALL
3918 Java_com_redhat_et_libguestfs_GuestFS__1resize2fs
3919   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3920 {
3921   guestfs_h *g = (guestfs_h *) (long) jg;
3922   int r;
3923   const char *device;
3924
3925   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3926   r = guestfs_resize2fs (g, device);
3927   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3928   if (r == -1) {
3929     throw_exception (env, guestfs_last_error (g));
3930     return ;
3931   }
3932 }
3933
3934 JNIEXPORT jobjectArray JNICALL
3935 Java_com_redhat_et_libguestfs_GuestFS__1find
3936   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
3937 {
3938   guestfs_h *g = (guestfs_h *) (long) jg;
3939   jobjectArray jr;
3940   int r_len;
3941   jclass cl;
3942   jstring jstr;
3943   char **r;
3944   const char *directory;
3945   int i;
3946
3947   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3948   r = guestfs_find (g, directory);
3949   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3950   if (r == NULL) {
3951     throw_exception (env, guestfs_last_error (g));
3952     return NULL;
3953   }
3954   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3955   cl = (*env)->FindClass (env, "java/lang/String");
3956   jstr = (*env)->NewStringUTF (env, "");
3957   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3958   for (i = 0; i < r_len; ++i) {
3959     jstr = (*env)->NewStringUTF (env, r[i]);
3960     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3961     free (r[i]);
3962   }
3963   free (r);
3964   return jr;
3965 }
3966
3967 JNIEXPORT void JNICALL
3968 Java_com_redhat_et_libguestfs_GuestFS__1e2fsck_1f
3969   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3970 {
3971   guestfs_h *g = (guestfs_h *) (long) jg;
3972   int r;
3973   const char *device;
3974
3975   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3976   r = guestfs_e2fsck_f (g, device);
3977   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3978   if (r == -1) {
3979     throw_exception (env, guestfs_last_error (g));
3980     return ;
3981   }
3982 }
3983
3984 JNIEXPORT void JNICALL
3985 Java_com_redhat_et_libguestfs_GuestFS__1sleep
3986   (JNIEnv *env, jobject obj, jlong jg, jint jsecs)
3987 {
3988   guestfs_h *g = (guestfs_h *) (long) jg;
3989   int r;
3990   int secs;
3991
3992   secs = jsecs;
3993   r = guestfs_sleep (g, secs);
3994   if (r == -1) {
3995     throw_exception (env, guestfs_last_error (g));
3996     return ;
3997   }
3998 }
3999
4000 JNIEXPORT jint JNICALL
4001 Java_com_redhat_et_libguestfs_GuestFS__1ntfs_13g_1probe
4002   (JNIEnv *env, jobject obj, jlong jg, jboolean jrw, jstring jdevice)
4003 {
4004   guestfs_h *g = (guestfs_h *) (long) jg;
4005   int r;
4006   int rw;
4007   const char *device;
4008
4009   rw = jrw;
4010   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4011   r = guestfs_ntfs_3g_probe (g, rw, device);
4012   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4013   if (r == -1) {
4014     throw_exception (env, guestfs_last_error (g));
4015     return 0;
4016   }
4017   return (jint) r;
4018 }
4019
4020 JNIEXPORT jstring JNICALL
4021 Java_com_redhat_et_libguestfs_GuestFS__1sh
4022   (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
4023 {
4024   guestfs_h *g = (guestfs_h *) (long) jg;
4025   jstring jr;
4026   char *r;
4027   const char *command;
4028
4029   command = (*env)->GetStringUTFChars (env, jcommand, NULL);
4030   r = guestfs_sh (g, command);
4031   (*env)->ReleaseStringUTFChars (env, jcommand, command);
4032   if (r == NULL) {
4033     throw_exception (env, guestfs_last_error (g));
4034     return NULL;
4035   }
4036   jr = (*env)->NewStringUTF (env, r);
4037   free (r);
4038   return jr;
4039 }
4040
4041 JNIEXPORT jobjectArray JNICALL
4042 Java_com_redhat_et_libguestfs_GuestFS__1sh_1lines
4043   (JNIEnv *env, jobject obj, jlong jg, jstring jcommand)
4044 {
4045   guestfs_h *g = (guestfs_h *) (long) jg;
4046   jobjectArray jr;
4047   int r_len;
4048   jclass cl;
4049   jstring jstr;
4050   char **r;
4051   const char *command;
4052   int i;
4053
4054   command = (*env)->GetStringUTFChars (env, jcommand, NULL);
4055   r = guestfs_sh_lines (g, command);
4056   (*env)->ReleaseStringUTFChars (env, jcommand, command);
4057   if (r == NULL) {
4058     throw_exception (env, guestfs_last_error (g));
4059     return NULL;
4060   }
4061   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4062   cl = (*env)->FindClass (env, "java/lang/String");
4063   jstr = (*env)->NewStringUTF (env, "");
4064   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4065   for (i = 0; i < r_len; ++i) {
4066     jstr = (*env)->NewStringUTF (env, r[i]);
4067     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4068     free (r[i]);
4069   }
4070   free (r);
4071   return jr;
4072 }
4073
4074 JNIEXPORT jobjectArray JNICALL
4075 Java_com_redhat_et_libguestfs_GuestFS__1glob_1expand
4076   (JNIEnv *env, jobject obj, jlong jg, jstring jpattern)
4077 {
4078   guestfs_h *g = (guestfs_h *) (long) jg;
4079   jobjectArray jr;
4080   int r_len;
4081   jclass cl;
4082   jstring jstr;
4083   char **r;
4084   const char *pattern;
4085   int i;
4086
4087   pattern = (*env)->GetStringUTFChars (env, jpattern, NULL);
4088   r = guestfs_glob_expand (g, pattern);
4089   (*env)->ReleaseStringUTFChars (env, jpattern, pattern);
4090   if (r == NULL) {
4091     throw_exception (env, guestfs_last_error (g));
4092     return NULL;
4093   }
4094   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4095   cl = (*env)->FindClass (env, "java/lang/String");
4096   jstr = (*env)->NewStringUTF (env, "");
4097   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4098   for (i = 0; i < r_len; ++i) {
4099     jstr = (*env)->NewStringUTF (env, r[i]);
4100     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4101     free (r[i]);
4102   }
4103   free (r);
4104   return jr;
4105 }
4106
4107 JNIEXPORT void JNICALL
4108 Java_com_redhat_et_libguestfs_GuestFS__1scrub_1device
4109   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
4110 {
4111   guestfs_h *g = (guestfs_h *) (long) jg;
4112   int r;
4113   const char *device;
4114
4115   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
4116   r = guestfs_scrub_device (g, device);
4117   (*env)->ReleaseStringUTFChars (env, jdevice, device);
4118   if (r == -1) {
4119     throw_exception (env, guestfs_last_error (g));
4120     return ;
4121   }
4122 }
4123
4124 JNIEXPORT void JNICALL
4125 Java_com_redhat_et_libguestfs_GuestFS__1scrub_1file
4126   (JNIEnv *env, jobject obj, jlong jg, jstring jfile)
4127 {
4128   guestfs_h *g = (guestfs_h *) (long) jg;
4129   int r;
4130   const char *file;
4131
4132   file = (*env)->GetStringUTFChars (env, jfile, NULL);
4133   r = guestfs_scrub_file (g, file);
4134   (*env)->ReleaseStringUTFChars (env, jfile, file);
4135   if (r == -1) {
4136     throw_exception (env, guestfs_last_error (g));
4137     return ;
4138   }
4139 }
4140
4141 JNIEXPORT void JNICALL
4142 Java_com_redhat_et_libguestfs_GuestFS__1scrub_1freespace
4143   (JNIEnv *env, jobject obj, jlong jg, jstring jdir)
4144 {
4145   guestfs_h *g = (guestfs_h *) (long) jg;
4146   int r;
4147   const char *dir;
4148
4149   dir = (*env)->GetStringUTFChars (env, jdir, NULL);
4150   r = guestfs_scrub_freespace (g, dir);
4151   (*env)->ReleaseStringUTFChars (env, jdir, dir);
4152   if (r == -1) {
4153     throw_exception (env, guestfs_last_error (g));
4154     return ;
4155   }
4156 }
4157
4158 JNIEXPORT jstring JNICALL
4159 Java_com_redhat_et_libguestfs_GuestFS__1mkdtemp
4160   (JNIEnv *env, jobject obj, jlong jg, jstring jtemplate)
4161 {
4162   guestfs_h *g = (guestfs_h *) (long) jg;
4163   jstring jr;
4164   char *r;
4165   const char *template;
4166
4167   template = (*env)->GetStringUTFChars (env, jtemplate, NULL);
4168   r = guestfs_mkdtemp (g, template);
4169   (*env)->ReleaseStringUTFChars (env, jtemplate, template);
4170   if (r == NULL) {
4171     throw_exception (env, guestfs_last_error (g));
4172     return NULL;
4173   }
4174   jr = (*env)->NewStringUTF (env, r);
4175   free (r);
4176   return jr;
4177 }
4178
4179 JNIEXPORT jint JNICALL
4180 Java_com_redhat_et_libguestfs_GuestFS__1wc_1l
4181   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4182 {
4183   guestfs_h *g = (guestfs_h *) (long) jg;
4184   int r;
4185   const char *path;
4186
4187   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4188   r = guestfs_wc_l (g, path);
4189   (*env)->ReleaseStringUTFChars (env, jpath, path);
4190   if (r == -1) {
4191     throw_exception (env, guestfs_last_error (g));
4192     return 0;
4193   }
4194   return (jint) r;
4195 }
4196
4197 JNIEXPORT jint JNICALL
4198 Java_com_redhat_et_libguestfs_GuestFS__1wc_1w
4199   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4200 {
4201   guestfs_h *g = (guestfs_h *) (long) jg;
4202   int r;
4203   const char *path;
4204
4205   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4206   r = guestfs_wc_w (g, path);
4207   (*env)->ReleaseStringUTFChars (env, jpath, path);
4208   if (r == -1) {
4209     throw_exception (env, guestfs_last_error (g));
4210     return 0;
4211   }
4212   return (jint) r;
4213 }
4214
4215 JNIEXPORT jint JNICALL
4216 Java_com_redhat_et_libguestfs_GuestFS__1wc_1c
4217   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4218 {
4219   guestfs_h *g = (guestfs_h *) (long) jg;
4220   int r;
4221   const char *path;
4222
4223   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4224   r = guestfs_wc_c (g, path);
4225   (*env)->ReleaseStringUTFChars (env, jpath, path);
4226   if (r == -1) {
4227     throw_exception (env, guestfs_last_error (g));
4228     return 0;
4229   }
4230   return (jint) r;
4231 }
4232
4233 JNIEXPORT jobjectArray JNICALL
4234 Java_com_redhat_et_libguestfs_GuestFS__1head
4235   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4236 {
4237   guestfs_h *g = (guestfs_h *) (long) jg;
4238   jobjectArray jr;
4239   int r_len;
4240   jclass cl;
4241   jstring jstr;
4242   char **r;
4243   const char *path;
4244   int i;
4245
4246   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4247   r = guestfs_head (g, path);
4248   (*env)->ReleaseStringUTFChars (env, jpath, path);
4249   if (r == NULL) {
4250     throw_exception (env, guestfs_last_error (g));
4251     return NULL;
4252   }
4253   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4254   cl = (*env)->FindClass (env, "java/lang/String");
4255   jstr = (*env)->NewStringUTF (env, "");
4256   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4257   for (i = 0; i < r_len; ++i) {
4258     jstr = (*env)->NewStringUTF (env, r[i]);
4259     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4260     free (r[i]);
4261   }
4262   free (r);
4263   return jr;
4264 }
4265
4266 JNIEXPORT jobjectArray JNICALL
4267 Java_com_redhat_et_libguestfs_GuestFS__1head_1n
4268   (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
4269 {
4270   guestfs_h *g = (guestfs_h *) (long) jg;
4271   jobjectArray jr;
4272   int r_len;
4273   jclass cl;
4274   jstring jstr;
4275   char **r;
4276   int nrlines;
4277   const char *path;
4278   int i;
4279
4280   nrlines = jnrlines;
4281   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4282   r = guestfs_head_n (g, nrlines, path);
4283   (*env)->ReleaseStringUTFChars (env, jpath, path);
4284   if (r == NULL) {
4285     throw_exception (env, guestfs_last_error (g));
4286     return NULL;
4287   }
4288   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4289   cl = (*env)->FindClass (env, "java/lang/String");
4290   jstr = (*env)->NewStringUTF (env, "");
4291   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4292   for (i = 0; i < r_len; ++i) {
4293     jstr = (*env)->NewStringUTF (env, r[i]);
4294     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4295     free (r[i]);
4296   }
4297   free (r);
4298   return jr;
4299 }
4300
4301 JNIEXPORT jobjectArray JNICALL
4302 Java_com_redhat_et_libguestfs_GuestFS__1tail
4303   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
4304 {
4305   guestfs_h *g = (guestfs_h *) (long) jg;
4306   jobjectArray jr;
4307   int r_len;
4308   jclass cl;
4309   jstring jstr;
4310   char **r;
4311   const char *path;
4312   int i;
4313
4314   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4315   r = guestfs_tail (g, path);
4316   (*env)->ReleaseStringUTFChars (env, jpath, path);
4317   if (r == NULL) {
4318     throw_exception (env, guestfs_last_error (g));
4319     return NULL;
4320   }
4321   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4322   cl = (*env)->FindClass (env, "java/lang/String");
4323   jstr = (*env)->NewStringUTF (env, "");
4324   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4325   for (i = 0; i < r_len; ++i) {
4326     jstr = (*env)->NewStringUTF (env, r[i]);
4327     (*env)->SetObjectArrayElement (env, jr, i, jstr);
4328     free (r[i]);
4329   }
4330   free (r);
4331   return jr;
4332 }
4333
4334 JNIEXPORT jobjectArray JNICALL
4335 Java_com_redhat_et_libguestfs_GuestFS__1tail_1n
4336   (JNIEnv *env, jobject obj, jlong jg, jint jnrlines, jstring jpath)
4337 {
4338   guestfs_h *g = (guestfs_h *) (long) jg;
4339   jobjectArray jr;
4340   int r_len;
4341   jclass cl;
4342   jstring jstr;
4343   char **r;
4344   int nrlines;
4345   const char *path;
4346   int i;
4347
4348   nrlines = jnrlines;
4349   path = (*env)->GetStringUTFChars (env, jpath, NULL);
4350   r = guestfs_tail_n (g, nrlines, path);
4351   (*env)->ReleaseStringUTFChars (env, jpath, path);
4352   if (r == NULL) {
4353     throw_exception (env, guestfs_last_error (g));
4354     return NULL;
4355   }
4356   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
4357   cl = (*env)->FindClass (env, "java/lang/String");
4358   jstr = (*env)->NewStringUTF (env, "");
4359   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
4360   for (i = 0; i < r_len; ++i) {