Generated code for 'du' command.
[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__1mount
1406   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
1407 {
1408   guestfs_h *g = (guestfs_h *) (long) jg;
1409   int r;
1410   const char *device;
1411   const char *mountpoint;
1412
1413   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1414   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
1415   r = guestfs_mount (g, device, mountpoint);
1416   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1417   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
1418   if (r == -1) {
1419     throw_exception (env, guestfs_last_error (g));
1420     return ;
1421   }
1422 }
1423
1424 JNIEXPORT void JNICALL
1425 Java_com_redhat_et_libguestfs_GuestFS__1sync
1426   (JNIEnv *env, jobject obj, jlong jg)
1427 {
1428   guestfs_h *g = (guestfs_h *) (long) jg;
1429   int r;
1430
1431   r = guestfs_sync (g);
1432   if (r == -1) {
1433     throw_exception (env, guestfs_last_error (g));
1434     return ;
1435   }
1436 }
1437
1438 JNIEXPORT void JNICALL
1439 Java_com_redhat_et_libguestfs_GuestFS__1touch
1440   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1441 {
1442   guestfs_h *g = (guestfs_h *) (long) jg;
1443   int r;
1444   const char *path;
1445
1446   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1447   r = guestfs_touch (g, path);
1448   (*env)->ReleaseStringUTFChars (env, jpath, path);
1449   if (r == -1) {
1450     throw_exception (env, guestfs_last_error (g));
1451     return ;
1452   }
1453 }
1454
1455 JNIEXPORT jstring JNICALL
1456 Java_com_redhat_et_libguestfs_GuestFS__1cat
1457   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1458 {
1459   guestfs_h *g = (guestfs_h *) (long) jg;
1460   jstring jr;
1461   char *r;
1462   const char *path;
1463
1464   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1465   r = guestfs_cat (g, path);
1466   (*env)->ReleaseStringUTFChars (env, jpath, path);
1467   if (r == NULL) {
1468     throw_exception (env, guestfs_last_error (g));
1469     return NULL;
1470   }
1471   jr = (*env)->NewStringUTF (env, r);
1472   free (r);
1473   return jr;
1474 }
1475
1476 JNIEXPORT jstring JNICALL
1477 Java_com_redhat_et_libguestfs_GuestFS__1ll
1478   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1479 {
1480   guestfs_h *g = (guestfs_h *) (long) jg;
1481   jstring jr;
1482   char *r;
1483   const char *directory;
1484
1485   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1486   r = guestfs_ll (g, directory);
1487   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1488   if (r == NULL) {
1489     throw_exception (env, guestfs_last_error (g));
1490     return NULL;
1491   }
1492   jr = (*env)->NewStringUTF (env, r);
1493   free (r);
1494   return jr;
1495 }
1496
1497 JNIEXPORT jobjectArray JNICALL
1498 Java_com_redhat_et_libguestfs_GuestFS__1ls
1499   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1500 {
1501   guestfs_h *g = (guestfs_h *) (long) jg;
1502   jobjectArray jr;
1503   int r_len;
1504   jclass cl;
1505   jstring jstr;
1506   char **r;
1507   const char *directory;
1508   int i;
1509
1510   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1511   r = guestfs_ls (g, directory);
1512   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1513   if (r == NULL) {
1514     throw_exception (env, guestfs_last_error (g));
1515     return NULL;
1516   }
1517   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1518   cl = (*env)->FindClass (env, "java/lang/String");
1519   jstr = (*env)->NewStringUTF (env, "");
1520   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1521   for (i = 0; i < r_len; ++i) {
1522     jstr = (*env)->NewStringUTF (env, r[i]);
1523     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1524     free (r[i]);
1525   }
1526   free (r);
1527   return jr;
1528 }
1529
1530 JNIEXPORT jobjectArray JNICALL
1531 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
1532   (JNIEnv *env, jobject obj, jlong jg)
1533 {
1534   guestfs_h *g = (guestfs_h *) (long) jg;
1535   jobjectArray jr;
1536   int r_len;
1537   jclass cl;
1538   jstring jstr;
1539   char **r;
1540   int i;
1541
1542   r = guestfs_list_devices (g);
1543   if (r == NULL) {
1544     throw_exception (env, guestfs_last_error (g));
1545     return NULL;
1546   }
1547   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1548   cl = (*env)->FindClass (env, "java/lang/String");
1549   jstr = (*env)->NewStringUTF (env, "");
1550   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1551   for (i = 0; i < r_len; ++i) {
1552     jstr = (*env)->NewStringUTF (env, r[i]);
1553     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1554     free (r[i]);
1555   }
1556   free (r);
1557   return jr;
1558 }
1559
1560 JNIEXPORT jobjectArray JNICALL
1561 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
1562   (JNIEnv *env, jobject obj, jlong jg)
1563 {
1564   guestfs_h *g = (guestfs_h *) (long) jg;
1565   jobjectArray jr;
1566   int r_len;
1567   jclass cl;
1568   jstring jstr;
1569   char **r;
1570   int i;
1571
1572   r = guestfs_list_partitions (g);
1573   if (r == NULL) {
1574     throw_exception (env, guestfs_last_error (g));
1575     return NULL;
1576   }
1577   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1578   cl = (*env)->FindClass (env, "java/lang/String");
1579   jstr = (*env)->NewStringUTF (env, "");
1580   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1581   for (i = 0; i < r_len; ++i) {
1582     jstr = (*env)->NewStringUTF (env, r[i]);
1583     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1584     free (r[i]);
1585   }
1586   free (r);
1587   return jr;
1588 }
1589
1590 JNIEXPORT jobjectArray JNICALL
1591 Java_com_redhat_et_libguestfs_GuestFS__1pvs
1592   (JNIEnv *env, jobject obj, jlong jg)
1593 {
1594   guestfs_h *g = (guestfs_h *) (long) jg;
1595   jobjectArray jr;
1596   int r_len;
1597   jclass cl;
1598   jstring jstr;
1599   char **r;
1600   int i;
1601
1602   r = guestfs_pvs (g);
1603   if (r == NULL) {
1604     throw_exception (env, guestfs_last_error (g));
1605     return NULL;
1606   }
1607   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1608   cl = (*env)->FindClass (env, "java/lang/String");
1609   jstr = (*env)->NewStringUTF (env, "");
1610   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1611   for (i = 0; i < r_len; ++i) {
1612     jstr = (*env)->NewStringUTF (env, r[i]);
1613     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1614     free (r[i]);
1615   }
1616   free (r);
1617   return jr;
1618 }
1619
1620 JNIEXPORT jobjectArray JNICALL
1621 Java_com_redhat_et_libguestfs_GuestFS__1vgs
1622   (JNIEnv *env, jobject obj, jlong jg)
1623 {
1624   guestfs_h *g = (guestfs_h *) (long) jg;
1625   jobjectArray jr;
1626   int r_len;
1627   jclass cl;
1628   jstring jstr;
1629   char **r;
1630   int i;
1631
1632   r = guestfs_vgs (g);
1633   if (r == NULL) {
1634     throw_exception (env, guestfs_last_error (g));
1635     return NULL;
1636   }
1637   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1638   cl = (*env)->FindClass (env, "java/lang/String");
1639   jstr = (*env)->NewStringUTF (env, "");
1640   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1641   for (i = 0; i < r_len; ++i) {
1642     jstr = (*env)->NewStringUTF (env, r[i]);
1643     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1644     free (r[i]);
1645   }
1646   free (r);
1647   return jr;
1648 }
1649
1650 JNIEXPORT jobjectArray JNICALL
1651 Java_com_redhat_et_libguestfs_GuestFS__1lvs
1652   (JNIEnv *env, jobject obj, jlong jg)
1653 {
1654   guestfs_h *g = (guestfs_h *) (long) jg;
1655   jobjectArray jr;
1656   int r_len;
1657   jclass cl;
1658   jstring jstr;
1659   char **r;
1660   int i;
1661
1662   r = guestfs_lvs (g);
1663   if (r == NULL) {
1664     throw_exception (env, guestfs_last_error (g));
1665     return NULL;
1666   }
1667   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1668   cl = (*env)->FindClass (env, "java/lang/String");
1669   jstr = (*env)->NewStringUTF (env, "");
1670   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1671   for (i = 0; i < r_len; ++i) {
1672     jstr = (*env)->NewStringUTF (env, r[i]);
1673     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1674     free (r[i]);
1675   }
1676   free (r);
1677   return jr;
1678 }
1679
1680 JNIEXPORT jobjectArray JNICALL
1681 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
1682   (JNIEnv *env, jobject obj, jlong jg)
1683 {
1684   guestfs_h *g = (guestfs_h *) (long) jg;
1685   jobjectArray jr;
1686   jclass cl;
1687   jfieldID fl;
1688   jobject jfl;
1689   struct guestfs_lvm_pv_list *r;
1690   int i;
1691
1692   r = guestfs_pvs_full (g);
1693   if (r == NULL) {
1694     throw_exception (env, guestfs_last_error (g));
1695     return NULL;
1696   }
1697   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
1698   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1699   for (i = 0; i < r->len; ++i) {
1700     jfl = (*env)->AllocObject (env, cl);
1701     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
1702     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
1703     {
1704       char s[33];
1705       memcpy (s, r->val[i].pv_uuid, 32);
1706       s[32] = 0;
1707       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
1708       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1709     }
1710     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
1711     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
1712     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
1713     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
1714     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
1715     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
1716     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
1717     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
1718     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
1719     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
1720     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
1721     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
1722     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
1723     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
1724     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
1725     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
1726     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
1727     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
1728     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
1729     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
1730     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
1731     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
1732     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
1733     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
1734     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1735   }
1736   guestfs_free_lvm_pv_list (r);
1737   return jr;
1738 }
1739
1740 JNIEXPORT jobjectArray JNICALL
1741 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
1742   (JNIEnv *env, jobject obj, jlong jg)
1743 {
1744   guestfs_h *g = (guestfs_h *) (long) jg;
1745   jobjectArray jr;
1746   jclass cl;
1747   jfieldID fl;
1748   jobject jfl;
1749   struct guestfs_lvm_vg_list *r;
1750   int i;
1751
1752   r = guestfs_vgs_full (g);
1753   if (r == NULL) {
1754     throw_exception (env, guestfs_last_error (g));
1755     return NULL;
1756   }
1757   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
1758   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1759   for (i = 0; i < r->len; ++i) {
1760     jfl = (*env)->AllocObject (env, cl);
1761     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
1762     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
1763     {
1764       char s[33];
1765       memcpy (s, r->val[i].vg_uuid, 32);
1766       s[32] = 0;
1767       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
1768       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1769     }
1770     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
1771     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
1772     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
1773     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
1774     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
1775     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
1776     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
1777     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
1778     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
1779     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
1780     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
1781     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
1782     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
1783     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
1784     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
1785     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
1786     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
1787     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
1788     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
1789     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
1790     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
1791     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
1792     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
1793     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
1794     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
1795     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
1796     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
1797     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
1798     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
1799     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
1800     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
1801     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
1802     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
1803     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
1804     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1805   }
1806   guestfs_free_lvm_vg_list (r);
1807   return jr;
1808 }
1809
1810 JNIEXPORT jobjectArray JNICALL
1811 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
1812   (JNIEnv *env, jobject obj, jlong jg)
1813 {
1814   guestfs_h *g = (guestfs_h *) (long) jg;
1815   jobjectArray jr;
1816   jclass cl;
1817   jfieldID fl;
1818   jobject jfl;
1819   struct guestfs_lvm_lv_list *r;
1820   int i;
1821
1822   r = guestfs_lvs_full (g);
1823   if (r == NULL) {
1824     throw_exception (env, guestfs_last_error (g));
1825     return NULL;
1826   }
1827   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
1828   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1829   for (i = 0; i < r->len; ++i) {
1830     jfl = (*env)->AllocObject (env, cl);
1831     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
1832     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
1833     {
1834       char s[33];
1835       memcpy (s, r->val[i].lv_uuid, 32);
1836       s[32] = 0;
1837       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
1838       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1839     }
1840     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
1841     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
1842     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
1843     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
1844     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
1845     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
1846     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
1847     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
1848     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
1849     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
1850     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
1851     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
1852     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
1853     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
1854     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
1855     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
1856     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
1857     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
1858     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
1859     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
1860     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
1861     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
1862     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
1863     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
1864     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
1865     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
1866     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
1867     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
1868     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1869   }
1870   guestfs_free_lvm_lv_list (r);
1871   return jr;
1872 }
1873
1874 JNIEXPORT jobjectArray JNICALL
1875 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
1876   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1877 {
1878   guestfs_h *g = (guestfs_h *) (long) jg;
1879   jobjectArray jr;
1880   int r_len;
1881   jclass cl;
1882   jstring jstr;
1883   char **r;
1884   const char *path;
1885   int i;
1886
1887   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1888   r = guestfs_read_lines (g, path);
1889   (*env)->ReleaseStringUTFChars (env, jpath, path);
1890   if (r == NULL) {
1891     throw_exception (env, guestfs_last_error (g));
1892     return NULL;
1893   }
1894   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1895   cl = (*env)->FindClass (env, "java/lang/String");
1896   jstr = (*env)->NewStringUTF (env, "");
1897   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1898   for (i = 0; i < r_len; ++i) {
1899     jstr = (*env)->NewStringUTF (env, r[i]);
1900     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1901     free (r[i]);
1902   }
1903   free (r);
1904   return jr;
1905 }
1906
1907 JNIEXPORT void JNICALL
1908 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
1909   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
1910 {
1911   guestfs_h *g = (guestfs_h *) (long) jg;
1912   int r;
1913   const char *root;
1914   int flags;
1915
1916   root = (*env)->GetStringUTFChars (env, jroot, NULL);
1917   flags = jflags;
1918   r = guestfs_aug_init (g, root, flags);
1919   (*env)->ReleaseStringUTFChars (env, jroot, root);
1920   if (r == -1) {
1921     throw_exception (env, guestfs_last_error (g));
1922     return ;
1923   }
1924 }
1925
1926 JNIEXPORT void JNICALL
1927 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
1928   (JNIEnv *env, jobject obj, jlong jg)
1929 {
1930   guestfs_h *g = (guestfs_h *) (long) jg;
1931   int r;
1932
1933   r = guestfs_aug_close (g);
1934   if (r == -1) {
1935     throw_exception (env, guestfs_last_error (g));
1936     return ;
1937   }
1938 }
1939
1940 JNIEXPORT jint JNICALL
1941 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
1942   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
1943 {
1944   guestfs_h *g = (guestfs_h *) (long) jg;
1945   int r;
1946   const char *name;
1947   const char *expr;
1948
1949   name = (*env)->GetStringUTFChars (env, jname, NULL);
1950   expr = jexpr ? (*env)->GetStringUTFChars (env, jexpr, NULL) : NULL;
1951   r = guestfs_aug_defvar (g, name, expr);
1952   (*env)->ReleaseStringUTFChars (env, jname, name);
1953   if (jexpr)
1954     (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1955   if (r == -1) {
1956     throw_exception (env, guestfs_last_error (g));
1957     return 0;
1958   }
1959   return (jint) r;
1960 }
1961
1962 JNIEXPORT jobject JNICALL
1963 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
1964   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
1965 {
1966   guestfs_h *g = (guestfs_h *) (long) jg;
1967   jobject jr;
1968   jclass cl;
1969   jfieldID fl;
1970   struct guestfs_int_bool *r;
1971   const char *name;
1972   const char *expr;
1973   const char *val;
1974
1975   name = (*env)->GetStringUTFChars (env, jname, NULL);
1976   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
1977   val = (*env)->GetStringUTFChars (env, jval, NULL);
1978   r = guestfs_aug_defnode (g, name, expr, val);
1979   (*env)->ReleaseStringUTFChars (env, jname, name);
1980   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1981   (*env)->ReleaseStringUTFChars (env, jval, val);
1982   if (r == NULL) {
1983     throw_exception (env, guestfs_last_error (g));
1984     return NULL;
1985   }
1986   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
1987   jr = (*env)->AllocObject (env, cl);
1988   fl = (*env)->GetFieldID (env, cl, "i", "I");
1989   (*env)->SetIntField (env, jr, fl, r->i);
1990   fl = (*env)->GetFieldID (env, cl, "i", "Z");
1991   (*env)->SetBooleanField (env, jr, fl, r->b);
1992   guestfs_free_int_bool (r);
1993   return jr;
1994 }
1995
1996 JNIEXPORT jstring JNICALL
1997 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
1998   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1999 {
2000   guestfs_h *g = (guestfs_h *) (long) jg;
2001   jstring jr;
2002   char *r;
2003   const char *path;
2004
2005   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2006   r = guestfs_aug_get (g, path);
2007   (*env)->ReleaseStringUTFChars (env, jpath, path);
2008   if (r == NULL) {
2009     throw_exception (env, guestfs_last_error (g));
2010     return NULL;
2011   }
2012   jr = (*env)->NewStringUTF (env, r);
2013   free (r);
2014   return jr;
2015 }
2016
2017 JNIEXPORT void JNICALL
2018 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
2019   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
2020 {
2021   guestfs_h *g = (guestfs_h *) (long) jg;
2022   int r;
2023   const char *path;
2024   const char *val;
2025
2026   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2027   val = (*env)->GetStringUTFChars (env, jval, NULL);
2028   r = guestfs_aug_set (g, path, val);
2029   (*env)->ReleaseStringUTFChars (env, jpath, path);
2030   (*env)->ReleaseStringUTFChars (env, jval, val);
2031   if (r == -1) {
2032     throw_exception (env, guestfs_last_error (g));
2033     return ;
2034   }
2035 }
2036
2037 JNIEXPORT void JNICALL
2038 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
2039   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
2040 {
2041   guestfs_h *g = (guestfs_h *) (long) jg;
2042   int r;
2043   const char *path;
2044   const char *label;
2045   int before;
2046
2047   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2048   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2049   before = jbefore;
2050   r = guestfs_aug_insert (g, path, label, before);
2051   (*env)->ReleaseStringUTFChars (env, jpath, path);
2052   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2053   if (r == -1) {
2054     throw_exception (env, guestfs_last_error (g));
2055     return ;
2056   }
2057 }
2058
2059 JNIEXPORT jint JNICALL
2060 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
2061   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2062 {
2063   guestfs_h *g = (guestfs_h *) (long) jg;
2064   int r;
2065   const char *path;
2066
2067   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2068   r = guestfs_aug_rm (g, path);
2069   (*env)->ReleaseStringUTFChars (env, jpath, path);
2070   if (r == -1) {
2071     throw_exception (env, guestfs_last_error (g));
2072     return 0;
2073   }
2074   return (jint) r;
2075 }
2076
2077 JNIEXPORT void JNICALL
2078 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
2079   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2080 {
2081   guestfs_h *g = (guestfs_h *) (long) jg;
2082   int r;
2083   const char *src;
2084   const char *dest;
2085
2086   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2087   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2088   r = guestfs_aug_mv (g, src, dest);
2089   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2090   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2091   if (r == -1) {
2092     throw_exception (env, guestfs_last_error (g));
2093     return ;
2094   }
2095 }
2096
2097 JNIEXPORT jobjectArray JNICALL
2098 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
2099   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2100 {
2101   guestfs_h *g = (guestfs_h *) (long) jg;
2102   jobjectArray jr;
2103   int r_len;
2104   jclass cl;
2105   jstring jstr;
2106   char **r;
2107   const char *path;
2108   int i;
2109
2110   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2111   r = guestfs_aug_match (g, path);
2112   (*env)->ReleaseStringUTFChars (env, jpath, path);
2113   if (r == NULL) {
2114     throw_exception (env, guestfs_last_error (g));
2115     return NULL;
2116   }
2117   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2118   cl = (*env)->FindClass (env, "java/lang/String");
2119   jstr = (*env)->NewStringUTF (env, "");
2120   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2121   for (i = 0; i < r_len; ++i) {
2122     jstr = (*env)->NewStringUTF (env, r[i]);
2123     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2124     free (r[i]);
2125   }
2126   free (r);
2127   return jr;
2128 }
2129
2130 JNIEXPORT void JNICALL
2131 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
2132   (JNIEnv *env, jobject obj, jlong jg)
2133 {
2134   guestfs_h *g = (guestfs_h *) (long) jg;
2135   int r;
2136
2137   r = guestfs_aug_save (g);
2138   if (r == -1) {
2139     throw_exception (env, guestfs_last_error (g));
2140     return ;
2141   }
2142 }
2143
2144 JNIEXPORT void JNICALL
2145 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
2146   (JNIEnv *env, jobject obj, jlong jg)
2147 {
2148   guestfs_h *g = (guestfs_h *) (long) jg;
2149   int r;
2150
2151   r = guestfs_aug_load (g);
2152   if (r == -1) {
2153     throw_exception (env, guestfs_last_error (g));
2154     return ;
2155   }
2156 }
2157
2158 JNIEXPORT jobjectArray JNICALL
2159 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
2160   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2161 {
2162   guestfs_h *g = (guestfs_h *) (long) jg;
2163   jobjectArray jr;
2164   int r_len;
2165   jclass cl;
2166   jstring jstr;
2167   char **r;
2168   const char *path;
2169   int i;
2170
2171   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2172   r = guestfs_aug_ls (g, path);
2173   (*env)->ReleaseStringUTFChars (env, jpath, path);
2174   if (r == NULL) {
2175     throw_exception (env, guestfs_last_error (g));
2176     return NULL;
2177   }
2178   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2179   cl = (*env)->FindClass (env, "java/lang/String");
2180   jstr = (*env)->NewStringUTF (env, "");
2181   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2182   for (i = 0; i < r_len; ++i) {
2183     jstr = (*env)->NewStringUTF (env, r[i]);
2184     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2185     free (r[i]);
2186   }
2187   free (r);
2188   return jr;
2189 }
2190
2191 JNIEXPORT void JNICALL
2192 Java_com_redhat_et_libguestfs_GuestFS__1rm
2193   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2194 {
2195   guestfs_h *g = (guestfs_h *) (long) jg;
2196   int r;
2197   const char *path;
2198
2199   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2200   r = guestfs_rm (g, path);
2201   (*env)->ReleaseStringUTFChars (env, jpath, path);
2202   if (r == -1) {
2203     throw_exception (env, guestfs_last_error (g));
2204     return ;
2205   }
2206 }
2207
2208 JNIEXPORT void JNICALL
2209 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
2210   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2211 {
2212   guestfs_h *g = (guestfs_h *) (long) jg;
2213   int r;
2214   const char *path;
2215
2216   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2217   r = guestfs_rmdir (g, path);
2218   (*env)->ReleaseStringUTFChars (env, jpath, path);
2219   if (r == -1) {
2220     throw_exception (env, guestfs_last_error (g));
2221     return ;
2222   }
2223 }
2224
2225 JNIEXPORT void JNICALL
2226 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
2227   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2228 {
2229   guestfs_h *g = (guestfs_h *) (long) jg;
2230   int r;
2231   const char *path;
2232
2233   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2234   r = guestfs_rm_rf (g, path);
2235   (*env)->ReleaseStringUTFChars (env, jpath, path);
2236   if (r == -1) {
2237     throw_exception (env, guestfs_last_error (g));
2238     return ;
2239   }
2240 }
2241
2242 JNIEXPORT void JNICALL
2243 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
2244   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2245 {
2246   guestfs_h *g = (guestfs_h *) (long) jg;
2247   int r;
2248   const char *path;
2249
2250   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2251   r = guestfs_mkdir (g, path);
2252   (*env)->ReleaseStringUTFChars (env, jpath, path);
2253   if (r == -1) {
2254     throw_exception (env, guestfs_last_error (g));
2255     return ;
2256   }
2257 }
2258
2259 JNIEXPORT void JNICALL
2260 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
2261   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2262 {
2263   guestfs_h *g = (guestfs_h *) (long) jg;
2264   int r;
2265   const char *path;
2266
2267   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2268   r = guestfs_mkdir_p (g, path);
2269   (*env)->ReleaseStringUTFChars (env, jpath, path);
2270   if (r == -1) {
2271     throw_exception (env, guestfs_last_error (g));
2272     return ;
2273   }
2274 }
2275
2276 JNIEXPORT void JNICALL
2277 Java_com_redhat_et_libguestfs_GuestFS__1chmod
2278   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
2279 {
2280   guestfs_h *g = (guestfs_h *) (long) jg;
2281   int r;
2282   int mode;
2283   const char *path;
2284
2285   mode = jmode;
2286   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2287   r = guestfs_chmod (g, mode, path);
2288   (*env)->ReleaseStringUTFChars (env, jpath, path);
2289   if (r == -1) {
2290     throw_exception (env, guestfs_last_error (g));
2291     return ;
2292   }
2293 }
2294
2295 JNIEXPORT void JNICALL
2296 Java_com_redhat_et_libguestfs_GuestFS__1chown
2297   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
2298 {
2299   guestfs_h *g = (guestfs_h *) (long) jg;
2300   int r;
2301   int owner;
2302   int group;
2303   const char *path;
2304
2305   owner = jowner;
2306   group = jgroup;
2307   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2308   r = guestfs_chown (g, owner, group, path);
2309   (*env)->ReleaseStringUTFChars (env, jpath, path);
2310   if (r == -1) {
2311     throw_exception (env, guestfs_last_error (g));
2312     return ;
2313   }
2314 }
2315
2316 JNIEXPORT jboolean JNICALL
2317 Java_com_redhat_et_libguestfs_GuestFS__1exists
2318   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2319 {
2320   guestfs_h *g = (guestfs_h *) (long) jg;
2321   int r;
2322   const char *path;
2323
2324   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2325   r = guestfs_exists (g, path);
2326   (*env)->ReleaseStringUTFChars (env, jpath, path);
2327   if (r == -1) {
2328     throw_exception (env, guestfs_last_error (g));
2329     return 0;
2330   }
2331   return (jboolean) r;
2332 }
2333
2334 JNIEXPORT jboolean JNICALL
2335 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
2336   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2337 {
2338   guestfs_h *g = (guestfs_h *) (long) jg;
2339   int r;
2340   const char *path;
2341
2342   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2343   r = guestfs_is_file (g, path);
2344   (*env)->ReleaseStringUTFChars (env, jpath, path);
2345   if (r == -1) {
2346     throw_exception (env, guestfs_last_error (g));
2347     return 0;
2348   }
2349   return (jboolean) r;
2350 }
2351
2352 JNIEXPORT jboolean JNICALL
2353 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
2354   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2355 {
2356   guestfs_h *g = (guestfs_h *) (long) jg;
2357   int r;
2358   const char *path;
2359
2360   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2361   r = guestfs_is_dir (g, path);
2362   (*env)->ReleaseStringUTFChars (env, jpath, path);
2363   if (r == -1) {
2364     throw_exception (env, guestfs_last_error (g));
2365     return 0;
2366   }
2367   return (jboolean) r;
2368 }
2369
2370 JNIEXPORT void JNICALL
2371 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
2372   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2373 {
2374   guestfs_h *g = (guestfs_h *) (long) jg;
2375   int r;
2376   const char *device;
2377
2378   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2379   r = guestfs_pvcreate (g, device);
2380   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2381   if (r == -1) {
2382     throw_exception (env, guestfs_last_error (g));
2383     return ;
2384   }
2385 }
2386
2387 JNIEXPORT void JNICALL
2388 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
2389   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
2390 {
2391   guestfs_h *g = (guestfs_h *) (long) jg;
2392   int r;
2393   const char *volgroup;
2394   int physvols_len;
2395   const char **physvols;
2396   int i;
2397
2398   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2399   physvols_len = (*env)->GetArrayLength (env, jphysvols);
2400   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
2401   for (i = 0; i < physvols_len; ++i) {
2402     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2403     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
2404   }
2405   physvols[physvols_len] = NULL;
2406   r = guestfs_vgcreate (g, volgroup, physvols);
2407   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2408   for (i = 0; i < physvols_len; ++i) {
2409     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2410     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
2411   }
2412   free (physvols);
2413   if (r == -1) {
2414     throw_exception (env, guestfs_last_error (g));
2415     return ;
2416   }
2417 }
2418
2419 JNIEXPORT void JNICALL
2420 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
2421   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
2422 {
2423   guestfs_h *g = (guestfs_h *) (long) jg;
2424   int r;
2425   const char *logvol;
2426   const char *volgroup;
2427   int mbytes;
2428
2429   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
2430   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2431   mbytes = jmbytes;
2432   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2433   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
2434   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2435   if (r == -1) {
2436     throw_exception (env, guestfs_last_error (g));
2437     return ;
2438   }
2439 }
2440
2441 JNIEXPORT void JNICALL
2442 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
2443   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2444 {
2445   guestfs_h *g = (guestfs_h *) (long) jg;
2446   int r;
2447   const char *fstype;
2448   const char *device;
2449
2450   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2451   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2452   r = guestfs_mkfs (g, fstype, device);
2453   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2454   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2455   if (r == -1) {
2456     throw_exception (env, guestfs_last_error (g));
2457     return ;
2458   }
2459 }
2460
2461 JNIEXPORT void JNICALL
2462 Java_com_redhat_et_libguestfs_GuestFS__1sfdisk
2463   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
2464 {
2465   guestfs_h *g = (guestfs_h *) (long) jg;
2466   int r;
2467   const char *device;
2468   int cyls;
2469   int heads;
2470   int sectors;
2471   int lines_len;
2472   const char **lines;
2473   int i;
2474
2475   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2476   cyls = jcyls;
2477   heads = jheads;
2478   sectors = jsectors;
2479   lines_len = (*env)->GetArrayLength (env, jlines);
2480   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
2481   for (i = 0; i < lines_len; ++i) {
2482     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2483     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
2484   }
2485   lines[lines_len] = NULL;
2486   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2487   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2488   for (i = 0; i < lines_len; ++i) {
2489     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2490     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
2491   }
2492   free (lines);
2493   if (r == -1) {
2494     throw_exception (env, guestfs_last_error (g));
2495     return ;
2496   }
2497 }
2498
2499 JNIEXPORT void JNICALL
2500 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
2501   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
2502 {
2503   guestfs_h *g = (guestfs_h *) (long) jg;
2504   int r;
2505   const char *path;
2506   const char *content;
2507   int size;
2508
2509   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2510   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
2511   size = jsize;
2512   r = guestfs_write_file (g, path, content, size);
2513   (*env)->ReleaseStringUTFChars (env, jpath, path);
2514   (*env)->ReleaseStringUTFChars (env, jcontent, content);
2515   if (r == -1) {
2516     throw_exception (env, guestfs_last_error (g));
2517     return ;
2518   }
2519 }
2520
2521 JNIEXPORT void JNICALL
2522 Java_com_redhat_et_libguestfs_GuestFS__1umount
2523   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
2524 {
2525   guestfs_h *g = (guestfs_h *) (long) jg;
2526   int r;
2527   const char *pathordevice;
2528
2529   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
2530   r = guestfs_umount (g, pathordevice);
2531   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
2532   if (r == -1) {
2533     throw_exception (env, guestfs_last_error (g));
2534     return ;
2535   }
2536 }
2537
2538 JNIEXPORT jobjectArray JNICALL
2539 Java_com_redhat_et_libguestfs_GuestFS__1mounts
2540   (JNIEnv *env, jobject obj, jlong jg)
2541 {
2542   guestfs_h *g = (guestfs_h *) (long) jg;
2543   jobjectArray jr;
2544   int r_len;
2545   jclass cl;
2546   jstring jstr;
2547   char **r;
2548   int i;
2549
2550   r = guestfs_mounts (g);
2551   if (r == NULL) {
2552     throw_exception (env, guestfs_last_error (g));
2553     return NULL;
2554   }
2555   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2556   cl = (*env)->FindClass (env, "java/lang/String");
2557   jstr = (*env)->NewStringUTF (env, "");
2558   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2559   for (i = 0; i < r_len; ++i) {
2560     jstr = (*env)->NewStringUTF (env, r[i]);
2561     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2562     free (r[i]);
2563   }
2564   free (r);
2565   return jr;
2566 }
2567
2568 JNIEXPORT void JNICALL
2569 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
2570   (JNIEnv *env, jobject obj, jlong jg)
2571 {
2572   guestfs_h *g = (guestfs_h *) (long) jg;
2573   int r;
2574
2575   r = guestfs_umount_all (g);
2576   if (r == -1) {
2577     throw_exception (env, guestfs_last_error (g));
2578     return ;
2579   }
2580 }
2581
2582 JNIEXPORT void JNICALL
2583 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
2584   (JNIEnv *env, jobject obj, jlong jg)
2585 {
2586   guestfs_h *g = (guestfs_h *) (long) jg;
2587   int r;
2588
2589   r = guestfs_lvm_remove_all (g);
2590   if (r == -1) {
2591     throw_exception (env, guestfs_last_error (g));
2592     return ;
2593   }
2594 }
2595
2596 JNIEXPORT jstring JNICALL
2597 Java_com_redhat_et_libguestfs_GuestFS__1file
2598   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2599 {
2600   guestfs_h *g = (guestfs_h *) (long) jg;
2601   jstring jr;
2602   char *r;
2603   const char *path;
2604
2605   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2606   r = guestfs_file (g, path);
2607   (*env)->ReleaseStringUTFChars (env, jpath, path);
2608   if (r == NULL) {
2609     throw_exception (env, guestfs_last_error (g));
2610     return NULL;
2611   }
2612   jr = (*env)->NewStringUTF (env, r);
2613   free (r);
2614   return jr;
2615 }
2616
2617 JNIEXPORT jstring JNICALL
2618 Java_com_redhat_et_libguestfs_GuestFS__1command
2619   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2620 {
2621   guestfs_h *g = (guestfs_h *) (long) jg;
2622   jstring jr;
2623   char *r;
2624   int arguments_len;
2625   const char **arguments;
2626   int i;
2627
2628   arguments_len = (*env)->GetArrayLength (env, jarguments);
2629   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2630   for (i = 0; i < arguments_len; ++i) {
2631     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2632     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2633   }
2634   arguments[arguments_len] = NULL;
2635   r = guestfs_command (g, arguments);
2636   for (i = 0; i < arguments_len; ++i) {
2637     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2638     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2639   }
2640   free (arguments);
2641   if (r == NULL) {
2642     throw_exception (env, guestfs_last_error (g));
2643     return NULL;
2644   }
2645   jr = (*env)->NewStringUTF (env, r);
2646   free (r);
2647   return jr;
2648 }
2649
2650 JNIEXPORT jobjectArray JNICALL
2651 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
2652   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2653 {
2654   guestfs_h *g = (guestfs_h *) (long) jg;
2655   jobjectArray jr;
2656   int r_len;
2657   jclass cl;
2658   jstring jstr;
2659   char **r;
2660   int arguments_len;
2661   const char **arguments;
2662   int i;
2663
2664   arguments_len = (*env)->GetArrayLength (env, jarguments);
2665   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2666   for (i = 0; i < arguments_len; ++i) {
2667     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2668     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2669   }
2670   arguments[arguments_len] = NULL;
2671   r = guestfs_command_lines (g, arguments);
2672   for (i = 0; i < arguments_len; ++i) {
2673     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2674     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2675   }
2676   free (arguments);
2677   if (r == NULL) {
2678     throw_exception (env, guestfs_last_error (g));
2679     return NULL;
2680   }
2681   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2682   cl = (*env)->FindClass (env, "java/lang/String");
2683   jstr = (*env)->NewStringUTF (env, "");
2684   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2685   for (i = 0; i < r_len; ++i) {
2686     jstr = (*env)->NewStringUTF (env, r[i]);
2687     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2688     free (r[i]);
2689   }
2690   free (r);
2691   return jr;
2692 }
2693
2694 JNIEXPORT jobject JNICALL
2695 Java_com_redhat_et_libguestfs_GuestFS__1stat
2696   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2697 {
2698   guestfs_h *g = (guestfs_h *) (long) jg;
2699   jobject jr;
2700   jclass cl;
2701   jfieldID fl;
2702   struct guestfs_stat *r;
2703   const char *path;
2704
2705   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2706   r = guestfs_stat (g, path);
2707   (*env)->ReleaseStringUTFChars (env, jpath, path);
2708   if (r == NULL) {
2709     throw_exception (env, guestfs_last_error (g));
2710     return NULL;
2711   }
2712   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2713   jr = (*env)->AllocObject (env, cl);
2714   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2715   (*env)->SetLongField (env, jr, fl, r->dev);
2716   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2717   (*env)->SetLongField (env, jr, fl, r->ino);
2718   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2719   (*env)->SetLongField (env, jr, fl, r->mode);
2720   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2721   (*env)->SetLongField (env, jr, fl, r->nlink);
2722   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2723   (*env)->SetLongField (env, jr, fl, r->uid);
2724   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2725   (*env)->SetLongField (env, jr, fl, r->gid);
2726   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2727   (*env)->SetLongField (env, jr, fl, r->rdev);
2728   fl = (*env)->GetFieldID (env, cl, "size", "J");
2729   (*env)->SetLongField (env, jr, fl, r->size);
2730   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2731   (*env)->SetLongField (env, jr, fl, r->blksize);
2732   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2733   (*env)->SetLongField (env, jr, fl, r->blocks);
2734   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2735   (*env)->SetLongField (env, jr, fl, r->atime);
2736   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2737   (*env)->SetLongField (env, jr, fl, r->mtime);
2738   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2739   (*env)->SetLongField (env, jr, fl, r->ctime);
2740   free (r);
2741   return jr;
2742 }
2743
2744 JNIEXPORT jobject JNICALL
2745 Java_com_redhat_et_libguestfs_GuestFS__1lstat
2746   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2747 {
2748   guestfs_h *g = (guestfs_h *) (long) jg;
2749   jobject jr;
2750   jclass cl;
2751   jfieldID fl;
2752   struct guestfs_stat *r;
2753   const char *path;
2754
2755   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2756   r = guestfs_lstat (g, path);
2757   (*env)->ReleaseStringUTFChars (env, jpath, path);
2758   if (r == NULL) {
2759     throw_exception (env, guestfs_last_error (g));
2760     return NULL;
2761   }
2762   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2763   jr = (*env)->AllocObject (env, cl);
2764   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2765   (*env)->SetLongField (env, jr, fl, r->dev);
2766   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2767   (*env)->SetLongField (env, jr, fl, r->ino);
2768   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2769   (*env)->SetLongField (env, jr, fl, r->mode);
2770   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2771   (*env)->SetLongField (env, jr, fl, r->nlink);
2772   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2773   (*env)->SetLongField (env, jr, fl, r->uid);
2774   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2775   (*env)->SetLongField (env, jr, fl, r->gid);
2776   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2777   (*env)->SetLongField (env, jr, fl, r->rdev);
2778   fl = (*env)->GetFieldID (env, cl, "size", "J");
2779   (*env)->SetLongField (env, jr, fl, r->size);
2780   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2781   (*env)->SetLongField (env, jr, fl, r->blksize);
2782   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2783   (*env)->SetLongField (env, jr, fl, r->blocks);
2784   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2785   (*env)->SetLongField (env, jr, fl, r->atime);
2786   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2787   (*env)->SetLongField (env, jr, fl, r->mtime);
2788   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2789   (*env)->SetLongField (env, jr, fl, r->ctime);
2790   free (r);
2791   return jr;
2792 }
2793
2794 JNIEXPORT jobject JNICALL
2795 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
2796   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2797 {
2798   guestfs_h *g = (guestfs_h *) (long) jg;
2799   jobject jr;
2800   jclass cl;
2801   jfieldID fl;
2802   struct guestfs_statvfs *r;
2803   const char *path;
2804
2805   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2806   r = guestfs_statvfs (g, path);
2807   (*env)->ReleaseStringUTFChars (env, jpath, path);
2808   if (r == NULL) {
2809     throw_exception (env, guestfs_last_error (g));
2810     return NULL;
2811   }
2812   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
2813   jr = (*env)->AllocObject (env, cl);
2814   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
2815   (*env)->SetLongField (env, jr, fl, r->bsize);
2816   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
2817   (*env)->SetLongField (env, jr, fl, r->frsize);
2818   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2819   (*env)->SetLongField (env, jr, fl, r->blocks);
2820   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
2821   (*env)->SetLongField (env, jr, fl, r->bfree);
2822   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
2823   (*env)->SetLongField (env, jr, fl, r->bavail);
2824   fl = (*env)->GetFieldID (env, cl, "files", "J");
2825   (*env)->SetLongField (env, jr, fl, r->files);
2826   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
2827   (*env)->SetLongField (env, jr, fl, r->ffree);
2828   fl = (*env)->GetFieldID (env, cl, "favail", "J");
2829   (*env)->SetLongField (env, jr, fl, r->favail);
2830   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
2831   (*env)->SetLongField (env, jr, fl, r->fsid);
2832   fl = (*env)->GetFieldID (env, cl, "flag", "J");
2833   (*env)->SetLongField (env, jr, fl, r->flag);
2834   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
2835   (*env)->SetLongField (env, jr, fl, r->namemax);
2836   free (r);
2837   return jr;
2838 }
2839
2840 JNIEXPORT jobject JNICALL
2841 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
2842   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2843 {
2844   guestfs_h *g = (guestfs_h *) (long) jg;
2845   char **r;
2846   const char *device;
2847
2848   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2849   r = guestfs_tune2fs_l (g, device);
2850   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2851   if (r == NULL) {
2852     throw_exception (env, guestfs_last_error (g));
2853     return NULL;
2854   }
2855   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
2856   return NULL;
2857 }
2858
2859 JNIEXPORT void JNICALL
2860 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
2861   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2862 {
2863   guestfs_h *g = (guestfs_h *) (long) jg;
2864   int r;
2865   const char *device;
2866
2867   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2868   r = guestfs_blockdev_setro (g, device);
2869   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2870   if (r == -1) {
2871     throw_exception (env, guestfs_last_error (g));
2872     return ;
2873   }
2874 }
2875
2876 JNIEXPORT void JNICALL
2877 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
2878   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2879 {
2880   guestfs_h *g = (guestfs_h *) (long) jg;
2881   int r;
2882   const char *device;
2883
2884   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2885   r = guestfs_blockdev_setrw (g, device);
2886   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2887   if (r == -1) {
2888     throw_exception (env, guestfs_last_error (g));
2889     return ;
2890   }
2891 }
2892
2893 JNIEXPORT jboolean JNICALL
2894 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
2895   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2896 {
2897   guestfs_h *g = (guestfs_h *) (long) jg;
2898   int r;
2899   const char *device;
2900
2901   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2902   r = guestfs_blockdev_getro (g, device);
2903   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2904   if (r == -1) {
2905     throw_exception (env, guestfs_last_error (g));
2906     return 0;
2907   }
2908   return (jboolean) r;
2909 }
2910
2911 JNIEXPORT jint JNICALL
2912 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
2913   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2914 {
2915   guestfs_h *g = (guestfs_h *) (long) jg;
2916   int r;
2917   const char *device;
2918
2919   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2920   r = guestfs_blockdev_getss (g, device);
2921   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2922   if (r == -1) {
2923     throw_exception (env, guestfs_last_error (g));
2924     return 0;
2925   }
2926   return (jint) r;
2927 }
2928
2929 JNIEXPORT jint JNICALL
2930 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
2931   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2932 {
2933   guestfs_h *g = (guestfs_h *) (long) jg;
2934   int r;
2935   const char *device;
2936
2937   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2938   r = guestfs_blockdev_getbsz (g, device);
2939   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2940   if (r == -1) {
2941     throw_exception (env, guestfs_last_error (g));
2942     return 0;
2943   }
2944   return (jint) r;
2945 }
2946
2947 JNIEXPORT void JNICALL
2948 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
2949   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
2950 {
2951   guestfs_h *g = (guestfs_h *) (long) jg;
2952   int r;
2953   const char *device;
2954   int blocksize;
2955
2956   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2957   blocksize = jblocksize;
2958   r = guestfs_blockdev_setbsz (g, device, blocksize);
2959   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2960   if (r == -1) {
2961     throw_exception (env, guestfs_last_error (g));
2962     return ;
2963   }
2964 }
2965
2966 JNIEXPORT jlong JNICALL
2967 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
2968   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2969 {
2970   guestfs_h *g = (guestfs_h *) (long) jg;
2971   int64_t r;
2972   const char *device;
2973
2974   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2975   r = guestfs_blockdev_getsz (g, device);
2976   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2977   if (r == -1) {
2978     throw_exception (env, guestfs_last_error (g));
2979     return 0;
2980   }
2981   return (jlong) r;
2982 }
2983
2984 JNIEXPORT jlong JNICALL
2985 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
2986   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2987 {
2988   guestfs_h *g = (guestfs_h *) (long) jg;
2989   int64_t r;
2990   const char *device;
2991
2992   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2993   r = guestfs_blockdev_getsize64 (g, device);
2994   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2995   if (r == -1) {
2996     throw_exception (env, guestfs_last_error (g));
2997     return 0;
2998   }
2999   return (jlong) r;
3000 }
3001
3002 JNIEXPORT void JNICALL
3003 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
3004   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3005 {
3006   guestfs_h *g = (guestfs_h *) (long) jg;
3007   int r;
3008   const char *device;
3009
3010   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3011   r = guestfs_blockdev_flushbufs (g, device);
3012   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3013   if (r == -1) {
3014     throw_exception (env, guestfs_last_error (g));
3015     return ;
3016   }
3017 }
3018
3019 JNIEXPORT void JNICALL
3020 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
3021   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3022 {
3023   guestfs_h *g = (guestfs_h *) (long) jg;
3024   int r;
3025   const char *device;
3026
3027   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3028   r = guestfs_blockdev_rereadpt (g, device);
3029   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3030   if (r == -1) {
3031     throw_exception (env, guestfs_last_error (g));
3032     return ;
3033   }
3034 }
3035
3036 JNIEXPORT void JNICALL
3037 Java_com_redhat_et_libguestfs_GuestFS__1upload
3038   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
3039 {
3040   guestfs_h *g = (guestfs_h *) (long) jg;
3041   int r;
3042   const char *filename;
3043   const char *remotefilename;
3044
3045   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3046   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3047   r = guestfs_upload (g, filename, remotefilename);
3048   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3049   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3050   if (r == -1) {
3051     throw_exception (env, guestfs_last_error (g));
3052     return ;
3053   }
3054 }
3055
3056 JNIEXPORT void JNICALL
3057 Java_com_redhat_et_libguestfs_GuestFS__1download
3058   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
3059 {
3060   guestfs_h *g = (guestfs_h *) (long) jg;
3061   int r;
3062   const char *remotefilename;
3063   const char *filename;
3064
3065   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3066   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3067   r = guestfs_download (g, remotefilename, filename);
3068   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3069   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3070   if (r == -1) {
3071     throw_exception (env, guestfs_last_error (g));
3072     return ;
3073   }
3074 }
3075
3076 JNIEXPORT jstring JNICALL
3077 Java_com_redhat_et_libguestfs_GuestFS__1checksum
3078   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
3079 {
3080   guestfs_h *g = (guestfs_h *) (long) jg;
3081   jstring jr;
3082   char *r;
3083   const char *csumtype;
3084   const char *path;
3085
3086   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
3087   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3088   r = guestfs_checksum (g, csumtype, path);
3089   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
3090   (*env)->ReleaseStringUTFChars (env, jpath, path);
3091   if (r == NULL) {
3092     throw_exception (env, guestfs_last_error (g));
3093     return NULL;
3094   }
3095   jr = (*env)->NewStringUTF (env, r);
3096   free (r);
3097   return jr;
3098 }
3099
3100 JNIEXPORT void JNICALL
3101 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
3102   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
3103 {
3104   guestfs_h *g = (guestfs_h *) (long) jg;
3105   int r;
3106   const char *tarfile;
3107   const char *directory;
3108
3109   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3110   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3111   r = guestfs_tar_in (g, tarfile, directory);
3112   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3113   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3114   if (r == -1) {
3115     throw_exception (env, guestfs_last_error (g));
3116     return ;
3117   }
3118 }
3119
3120 JNIEXPORT void JNICALL
3121 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
3122   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
3123 {
3124   guestfs_h *g = (guestfs_h *) (long) jg;
3125   int r;
3126   const char *directory;
3127   const char *tarfile;
3128
3129   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3130   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3131   r = guestfs_tar_out (g, directory, tarfile);
3132   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3133   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3134   if (r == -1) {
3135     throw_exception (env, guestfs_last_error (g));
3136     return ;
3137   }
3138 }
3139
3140 JNIEXPORT void JNICALL
3141 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1in
3142   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
3143 {
3144   guestfs_h *g = (guestfs_h *) (long) jg;
3145   int r;
3146   const char *tarball;
3147   const char *directory;
3148
3149   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3150   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3151   r = guestfs_tgz_in (g, tarball, directory);
3152   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3153   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3154   if (r == -1) {
3155     throw_exception (env, guestfs_last_error (g));
3156     return ;
3157   }
3158 }
3159
3160 JNIEXPORT void JNICALL
3161 Java_com_redhat_et_libguestfs_GuestFS__1tgz_1out
3162   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
3163 {
3164   guestfs_h *g = (guestfs_h *) (long) jg;
3165   int r;
3166   const char *directory;
3167   const char *tarball;
3168
3169   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3170   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3171   r = guestfs_tgz_out (g, directory, tarball);
3172   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3173   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3174   if (r == -1) {
3175     throw_exception (env, guestfs_last_error (g));
3176     return ;
3177   }
3178 }
3179
3180 JNIEXPORT void JNICALL
3181 Java_com_redhat_et_libguestfs_GuestFS__1mount_1ro
3182   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
3183 {
3184   guestfs_h *g = (guestfs_h *) (long) jg;
3185   int r;
3186   const char *device;
3187   const char *mountpoint;
3188
3189   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3190   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3191   r = guestfs_mount_ro (g, device, mountpoint);
3192   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3193   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3194   if (r == -1) {
3195     throw_exception (env, guestfs_last_error (g));
3196     return ;
3197   }
3198 }
3199
3200 JNIEXPORT void JNICALL
3201 Java_com_redhat_et_libguestfs_GuestFS__1mount_1options
3202   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
3203 {
3204   guestfs_h *g = (guestfs_h *) (long) jg;
3205   int r;
3206   const char *options;
3207   const char *device;
3208   const char *mountpoint;
3209
3210   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3211   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3212   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3213   r = guestfs_mount_options (g, options, device, mountpoint);
3214   (*env)->ReleaseStringUTFChars (env, joptions, options);
3215   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3216   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3217   if (r == -1) {
3218     throw_exception (env, guestfs_last_error (g));
3219     return ;
3220   }
3221 }
3222
3223 JNIEXPORT void JNICALL
3224 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
3225   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
3226 {
3227   guestfs_h *g = (guestfs_h *) (long) jg;
3228   int r;
3229   const char *options;
3230   const char *vfstype;
3231   const char *device;
3232   const char *mountpoint;
3233
3234   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3235   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
3236   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3237   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3238   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3239   (*env)->ReleaseStringUTFChars (env, joptions, options);
3240   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
3241   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3242   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3243   if (r == -1) {
3244     throw_exception (env, guestfs_last_error (g));
3245     return ;
3246   }
3247 }
3248
3249 JNIEXPORT jstring JNICALL
3250 Java_com_redhat_et_libguestfs_GuestFS__1debug
3251   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
3252 {
3253   guestfs_h *g = (guestfs_h *) (long) jg;
3254   jstring jr;
3255   char *r;
3256   const char *subcmd;
3257   int extraargs_len;
3258   const char **extraargs;
3259   int i;
3260
3261   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
3262   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
3263   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
3264   for (i = 0; i < extraargs_len; ++i) {
3265     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3266     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
3267   }
3268   extraargs[extraargs_len] = NULL;
3269   r = guestfs_debug (g, subcmd, extraargs);
3270   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
3271   for (i = 0; i < extraargs_len; ++i) {
3272     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3273     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
3274   }
3275   free (extraargs);
3276   if (r == NULL) {
3277     throw_exception (env, guestfs_last_error (g));
3278     return NULL;
3279   }
3280   jr = (*env)->NewStringUTF (env, r);
3281   free (r);
3282   return jr;
3283 }
3284
3285 JNIEXPORT void JNICALL
3286 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
3287   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3288 {
3289   guestfs_h *g = (guestfs_h *) (long) jg;
3290   int r;
3291   const char *device;
3292
3293   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3294   r = guestfs_lvremove (g, device);
3295   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3296   if (r == -1) {
3297     throw_exception (env, guestfs_last_error (g));
3298     return ;
3299   }
3300 }
3301
3302 JNIEXPORT void JNICALL
3303 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
3304   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
3305 {
3306   guestfs_h *g = (guestfs_h *) (long) jg;
3307   int r;
3308   const char *vgname;
3309
3310   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
3311   r = guestfs_vgremove (g, vgname);
3312   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
3313   if (r == -1) {
3314     throw_exception (env, guestfs_last_error (g));
3315     return ;
3316   }
3317 }
3318
3319 JNIEXPORT void JNICALL
3320 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
3321   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3322 {
3323   guestfs_h *g = (guestfs_h *) (long) jg;
3324   int r;
3325   const char *device;
3326
3327   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3328   r = guestfs_pvremove (g, device);
3329   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3330   if (r == -1) {
3331     throw_exception (env, guestfs_last_error (g));
3332     return ;
3333   }
3334 }
3335
3336 JNIEXPORT void JNICALL
3337 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
3338   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
3339 {
3340   guestfs_h *g = (guestfs_h *) (long) jg;
3341   int r;
3342   const char *device;
3343   const char *label;
3344
3345   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3346   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
3347   r = guestfs_set_e2label (g, device, label);
3348   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3349   (*env)->ReleaseStringUTFChars (env, jlabel, label);
3350   if (r == -1) {
3351     throw_exception (env, guestfs_last_error (g));
3352     return ;
3353   }
3354 }
3355
3356 JNIEXPORT jstring JNICALL
3357 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
3358   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3359 {
3360   guestfs_h *g = (guestfs_h *) (long) jg;
3361   jstring jr;
3362   char *r;
3363   const char *device;
3364
3365   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3366   r = guestfs_get_e2label (g, device);
3367   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3368   if (r == NULL) {
3369     throw_exception (env, guestfs_last_error (g));
3370     return NULL;
3371   }
3372   jr = (*env)->NewStringUTF (env, r);
3373   free (r);
3374   return jr;
3375 }
3376
3377 JNIEXPORT void JNICALL
3378 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
3379   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
3380 {
3381   guestfs_h *g = (guestfs_h *) (long) jg;
3382   int r;
3383   const char *device;
3384   const char *uuid;
3385
3386   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3387   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
3388   r = guestfs_set_e2uuid (g, device, uuid);
3389   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3390   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
3391   if (r == -1) {
3392     throw_exception (env, guestfs_last_error (g));
3393     return ;
3394   }
3395 }
3396
3397 JNIEXPORT jstring JNICALL
3398 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
3399   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3400 {
3401   guestfs_h *g = (guestfs_h *) (long) jg;
3402   jstring jr;
3403   char *r;
3404   const char *device;
3405
3406   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3407   r = guestfs_get_e2uuid (g, device);
3408   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3409   if (r == NULL) {
3410     throw_exception (env, guestfs_last_error (g));
3411     return NULL;
3412   }
3413   jr = (*env)->NewStringUTF (env, r);
3414   free (r);
3415   return jr;
3416 }
3417
3418 JNIEXPORT jint JNICALL
3419 Java_com_redhat_et_libguestfs_GuestFS__1fsck
3420   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
3421 {
3422   guestfs_h *g = (guestfs_h *) (long) jg;
3423   int r;
3424   const char *fstype;
3425   const char *device;
3426
3427   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
3428   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3429   r = guestfs_fsck (g, fstype, device);
3430   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
3431   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3432   if (r == -1) {
3433     throw_exception (env, guestfs_last_error (g));
3434     return 0;
3435   }
3436   return (jint) r;
3437 }
3438
3439 JNIEXPORT void JNICALL
3440 Java_com_redhat_et_libguestfs_GuestFS__1zero
3441   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3442 {
3443   guestfs_h *g = (guestfs_h *) (long) jg;
3444   int r;
3445   const char *device;
3446
3447   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3448   r = guestfs_zero (g, device);
3449   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3450   if (r == -1) {
3451     throw_exception (env, guestfs_last_error (g));
3452     return ;
3453   }
3454 }
3455
3456 JNIEXPORT void JNICALL
3457 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
3458   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
3459 {
3460   guestfs_h *g = (guestfs_h *) (long) jg;
3461   int r;
3462   const char *root;
3463   const char *device;
3464
3465   root = (*env)->GetStringUTFChars (env, jroot, NULL);
3466   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3467   r = guestfs_grub_install (g, root, device);
3468   (*env)->ReleaseStringUTFChars (env, jroot, root);
3469   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3470   if (r == -1) {
3471     throw_exception (env, guestfs_last_error (g));
3472     return ;
3473   }
3474 }
3475
3476 JNIEXPORT void JNICALL
3477 Java_com_redhat_et_libguestfs_GuestFS__1cp
3478   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3479 {
3480   guestfs_h *g = (guestfs_h *) (long) jg;
3481   int r;
3482   const char *src;
3483   const char *dest;
3484
3485   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3486   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3487   r = guestfs_cp (g, src, dest);
3488   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3489   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3490   if (r == -1) {
3491     throw_exception (env, guestfs_last_error (g));
3492     return ;
3493   }
3494 }
3495
3496 JNIEXPORT void JNICALL
3497 Java_com_redhat_et_libguestfs_GuestFS__1cp_1a
3498   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3499 {
3500   guestfs_h *g = (guestfs_h *) (long) jg;
3501   int r;
3502   const char *src;
3503   const char *dest;
3504
3505   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3506   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3507   r = guestfs_cp_a (g, src, dest);
3508   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3509   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3510   if (r == -1) {
3511     throw_exception (env, guestfs_last_error (g));
3512     return ;
3513   }
3514 }
3515
3516 JNIEXPORT void JNICALL
3517 Java_com_redhat_et_libguestfs_GuestFS__1mv
3518   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3519 {
3520   guestfs_h *g = (guestfs_h *) (long) jg;
3521   int r;
3522   const char *src;
3523   const char *dest;
3524
3525   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3526   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3527   r = guestfs_mv (g, src, dest);
3528   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3529   (*env)->ReleaseStringUTFChars (env, jdest, dest);
3530   if (r == -1) {
3531     throw_exception (env, guestfs_last_error (g));
3532     return ;
3533   }
3534 }
3535
3536 JNIEXPORT void JNICALL
3537 Java_com_redhat_et_libguestfs_GuestFS__1drop_1caches
3538   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
3539 {
3540   guestfs_h *g = (guestfs_h *) (long) jg;
3541   int r;
3542   int whattodrop;
3543
3544   whattodrop = jwhattodrop;
3545   r = guestfs_drop_caches (g, whattodrop);
3546   if (r == -1) {
3547     throw_exception (env, guestfs_last_error (g));
3548     return ;
3549   }
3550 }
3551
3552 JNIEXPORT jstring JNICALL
3553 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
3554   (JNIEnv *env, jobject obj, jlong jg)
3555 {
3556   guestfs_h *g = (guestfs_h *) (long) jg;
3557   jstring jr;
3558   char *r;
3559
3560   r = guestfs_dmesg (g);
3561   if (r == NULL) {
3562     throw_exception (env, guestfs_last_error (g));
3563     return NULL;
3564   }
3565   jr = (*env)->NewStringUTF (env, r);
3566   free (r);
3567   return jr;
3568 }
3569
3570 JNIEXPORT void JNICALL
3571 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
3572   (JNIEnv *env, jobject obj, jlong jg)
3573 {
3574   guestfs_h *g = (guestfs_h *) (long) jg;
3575   int r;
3576
3577   r = guestfs_ping_daemon (g);
3578   if (r == -1) {
3579     throw_exception (env, guestfs_last_error (g));
3580     return ;
3581   }
3582 }
3583
3584 JNIEXPORT jboolean JNICALL
3585 Java_com_redhat_et_libguestfs_GuestFS__1equal
3586   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
3587 {
3588   guestfs_h *g = (guestfs_h *) (long) jg;
3589   int r;
3590   const char *file1;
3591   const char *file2;
3592
3593   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
3594   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
3595   r = guestfs_equal (g, file1, file2);
3596   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
3597   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
3598   if (r == -1) {
3599     throw_exception (env, guestfs_last_error (g));
3600     return 0;
3601   }
3602   return (jboolean) r;
3603 }
3604
3605 JNIEXPORT jobjectArray JNICALL
3606 Java_com_redhat_et_libguestfs_GuestFS__1strings
3607   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3608 {
3609   guestfs_h *g = (guestfs_h *) (long) jg;
3610   jobjectArray jr;
3611   int r_len;
3612   jclass cl;
3613   jstring jstr;
3614   char **r;
3615   const char *path;
3616   int i;
3617
3618   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3619   r = guestfs_strings (g, path);
3620   (*env)->ReleaseStringUTFChars (env, jpath, path);
3621   if (r == NULL) {
3622     throw_exception (env, guestfs_last_error (g));
3623     return NULL;
3624   }
3625   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3626   cl = (*env)->FindClass (env, "java/lang/String");
3627   jstr = (*env)->NewStringUTF (env, "");
3628   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3629   for (i = 0; i < r_len; ++i) {
3630     jstr = (*env)->NewStringUTF (env, r[i]);
3631     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3632     free (r[i]);
3633   }
3634   free (r);
3635   return jr;
3636 }
3637
3638 JNIEXPORT jobjectArray JNICALL
3639 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
3640   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
3641 {
3642   guestfs_h *g = (guestfs_h *) (long) jg;
3643   jobjectArray jr;
3644   int r_len;
3645   jclass cl;
3646   jstring jstr;
3647   char **r;
3648   const char *encoding;
3649   const char *path;
3650   int i;
3651
3652   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
3653   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3654   r = guestfs_strings_e (g, encoding, path);
3655   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
3656   (*env)->ReleaseStringUTFChars (env, jpath, path);
3657   if (r == NULL) {
3658     throw_exception (env, guestfs_last_error (g));
3659     return NULL;
3660   }
3661   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3662   cl = (*env)->FindClass (env, "java/lang/String");