Add the test0* functions, used to test language bindings.
[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 = (*env)->GetStringUTFChars (env, joptstr, 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   (*env)->ReleaseStringUTFChars (env, joptstr, optstr);
96   for (i = 0; i < strlist_len; ++i) {
97     jobject o = (*env)->GetObjectArrayElement (env, jstrlist, i);
98     (*env)->ReleaseStringUTFChars (env, o, strlist[i]);
99   }
100   free (strlist);
101   (*env)->ReleaseStringUTFChars (env, jfilein, filein);
102   (*env)->ReleaseStringUTFChars (env, jfileout, fileout);
103   if (r == -1) {
104     throw_exception (env, guestfs_last_error (g));
105     return ;
106   }
107 }
108
109 JNIEXPORT jint JNICALL
110 Java_com_redhat_et_libguestfs_GuestFS__1test0rint
111   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
112 {
113   guestfs_h *g = (guestfs_h *) (long) jg;
114   int r;
115   const char *val;
116
117   val = (*env)->GetStringUTFChars (env, jval, NULL);
118   r = guestfs_test0rint (g, val);
119   (*env)->ReleaseStringUTFChars (env, jval, val);
120   if (r == -1) {
121     throw_exception (env, guestfs_last_error (g));
122     return 0;
123   }
124   return (jint) r;
125 }
126
127 JNIEXPORT jint JNICALL
128 Java_com_redhat_et_libguestfs_GuestFS__1test0rinterr
129   (JNIEnv *env, jobject obj, jlong jg)
130 {
131   guestfs_h *g = (guestfs_h *) (long) jg;
132   int r;
133
134   r = guestfs_test0rinterr (g);
135   if (r == -1) {
136     throw_exception (env, guestfs_last_error (g));
137     return 0;
138   }
139   return (jint) r;
140 }
141
142 JNIEXPORT jlong JNICALL
143 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64
144   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
145 {
146   guestfs_h *g = (guestfs_h *) (long) jg;
147   int64_t r;
148   const char *val;
149
150   val = (*env)->GetStringUTFChars (env, jval, NULL);
151   r = guestfs_test0rint64 (g, val);
152   (*env)->ReleaseStringUTFChars (env, jval, val);
153   if (r == -1) {
154     throw_exception (env, guestfs_last_error (g));
155     return 0;
156   }
157   return (jlong) r;
158 }
159
160 JNIEXPORT jlong JNICALL
161 Java_com_redhat_et_libguestfs_GuestFS__1test0rint64err
162   (JNIEnv *env, jobject obj, jlong jg)
163 {
164   guestfs_h *g = (guestfs_h *) (long) jg;
165   int64_t r;
166
167   r = guestfs_test0rint64err (g);
168   if (r == -1) {
169     throw_exception (env, guestfs_last_error (g));
170     return 0;
171   }
172   return (jlong) r;
173 }
174
175 JNIEXPORT jboolean JNICALL
176 Java_com_redhat_et_libguestfs_GuestFS__1test0rbool
177   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
178 {
179   guestfs_h *g = (guestfs_h *) (long) jg;
180   int r;
181   const char *val;
182
183   val = (*env)->GetStringUTFChars (env, jval, NULL);
184   r = guestfs_test0rbool (g, val);
185   (*env)->ReleaseStringUTFChars (env, jval, val);
186   if (r == -1) {
187     throw_exception (env, guestfs_last_error (g));
188     return 0;
189   }
190   return (jboolean) r;
191 }
192
193 JNIEXPORT jboolean JNICALL
194 Java_com_redhat_et_libguestfs_GuestFS__1test0rboolerr
195   (JNIEnv *env, jobject obj, jlong jg)
196 {
197   guestfs_h *g = (guestfs_h *) (long) jg;
198   int r;
199
200   r = guestfs_test0rboolerr (g);
201   if (r == -1) {
202     throw_exception (env, guestfs_last_error (g));
203     return 0;
204   }
205   return (jboolean) r;
206 }
207
208 JNIEXPORT jstring JNICALL
209 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststring
210   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
211 {
212   guestfs_h *g = (guestfs_h *) (long) jg;
213   const char *r;
214   const char *val;
215
216   val = (*env)->GetStringUTFChars (env, jval, NULL);
217   r = guestfs_test0rconststring (g, val);
218   (*env)->ReleaseStringUTFChars (env, jval, val);
219   if (r == NULL) {
220     throw_exception (env, guestfs_last_error (g));
221     return NULL;
222   }
223   return (*env)->NewStringUTF (env, r);
224 }
225
226 JNIEXPORT jstring JNICALL
227 Java_com_redhat_et_libguestfs_GuestFS__1test0rconststringerr
228   (JNIEnv *env, jobject obj, jlong jg)
229 {
230   guestfs_h *g = (guestfs_h *) (long) jg;
231   const char *r;
232
233   r = guestfs_test0rconststringerr (g);
234   if (r == NULL) {
235     throw_exception (env, guestfs_last_error (g));
236     return NULL;
237   }
238   return (*env)->NewStringUTF (env, r);
239 }
240
241 JNIEXPORT jstring JNICALL
242 Java_com_redhat_et_libguestfs_GuestFS__1test0rstring
243   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
244 {
245   guestfs_h *g = (guestfs_h *) (long) jg;
246   jstring jr;
247   char *r;
248   const char *val;
249
250   val = (*env)->GetStringUTFChars (env, jval, NULL);
251   r = guestfs_test0rstring (g, val);
252   (*env)->ReleaseStringUTFChars (env, jval, val);
253   if (r == NULL) {
254     throw_exception (env, guestfs_last_error (g));
255     return NULL;
256   }
257   jr = (*env)->NewStringUTF (env, r);
258   free (r);
259   return jr;
260 }
261
262 JNIEXPORT jstring JNICALL
263 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringerr
264   (JNIEnv *env, jobject obj, jlong jg)
265 {
266   guestfs_h *g = (guestfs_h *) (long) jg;
267   jstring jr;
268   char *r;
269
270   r = guestfs_test0rstringerr (g);
271   if (r == NULL) {
272     throw_exception (env, guestfs_last_error (g));
273     return NULL;
274   }
275   jr = (*env)->NewStringUTF (env, r);
276   free (r);
277   return jr;
278 }
279
280 JNIEXPORT jobjectArray JNICALL
281 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlist
282   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
283 {
284   guestfs_h *g = (guestfs_h *) (long) jg;
285   jobjectArray jr;
286   int r_len;
287   jclass cl;
288   jstring jstr;
289   char **r;
290   const char *val;
291   int i;
292
293   val = (*env)->GetStringUTFChars (env, jval, NULL);
294   r = guestfs_test0rstringlist (g, val);
295   (*env)->ReleaseStringUTFChars (env, jval, val);
296   if (r == NULL) {
297     throw_exception (env, guestfs_last_error (g));
298     return NULL;
299   }
300   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
301   cl = (*env)->FindClass (env, "java/lang/String");
302   jstr = (*env)->NewStringUTF (env, "");
303   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
304   for (i = 0; i < r_len; ++i) {
305     jstr = (*env)->NewStringUTF (env, r[i]);
306     (*env)->SetObjectArrayElement (env, jr, i, jstr);
307     free (r[i]);
308   }
309   free (r);
310   return jr;
311 }
312
313 JNIEXPORT jobjectArray JNICALL
314 Java_com_redhat_et_libguestfs_GuestFS__1test0rstringlisterr
315   (JNIEnv *env, jobject obj, jlong jg)
316 {
317   guestfs_h *g = (guestfs_h *) (long) jg;
318   jobjectArray jr;
319   int r_len;
320   jclass cl;
321   jstring jstr;
322   char **r;
323   int i;
324
325   r = guestfs_test0rstringlisterr (g);
326   if (r == NULL) {
327     throw_exception (env, guestfs_last_error (g));
328     return NULL;
329   }
330   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
331   cl = (*env)->FindClass (env, "java/lang/String");
332   jstr = (*env)->NewStringUTF (env, "");
333   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
334   for (i = 0; i < r_len; ++i) {
335     jstr = (*env)->NewStringUTF (env, r[i]);
336     (*env)->SetObjectArrayElement (env, jr, i, jstr);
337     free (r[i]);
338   }
339   free (r);
340   return jr;
341 }
342
343 JNIEXPORT jobject JNICALL
344 Java_com_redhat_et_libguestfs_GuestFS__1test0rintbool
345   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
346 {
347   guestfs_h *g = (guestfs_h *) (long) jg;
348   jobject jr;
349   jclass cl;
350   jfieldID fl;
351   struct guestfs_int_bool *r;
352   const char *val;
353
354   val = (*env)->GetStringUTFChars (env, jval, NULL);
355   r = guestfs_test0rintbool (g, val);
356   (*env)->ReleaseStringUTFChars (env, jval, val);
357   if (r == NULL) {
358     throw_exception (env, guestfs_last_error (g));
359     return NULL;
360   }
361   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
362   jr = (*env)->AllocObject (env, cl);
363   fl = (*env)->GetFieldID (env, cl, "i", "I");
364   (*env)->SetIntField (env, jr, fl, r->i);
365   fl = (*env)->GetFieldID (env, cl, "i", "Z");
366   (*env)->SetBooleanField (env, jr, fl, r->b);
367   guestfs_free_int_bool (r);
368   return jr;
369 }
370
371 JNIEXPORT jobject JNICALL
372 Java_com_redhat_et_libguestfs_GuestFS__1test0rintboolerr
373   (JNIEnv *env, jobject obj, jlong jg)
374 {
375   guestfs_h *g = (guestfs_h *) (long) jg;
376   jobject jr;
377   jclass cl;
378   jfieldID fl;
379   struct guestfs_int_bool *r;
380
381   r = guestfs_test0rintboolerr (g);
382   if (r == NULL) {
383     throw_exception (env, guestfs_last_error (g));
384     return NULL;
385   }
386   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
387   jr = (*env)->AllocObject (env, cl);
388   fl = (*env)->GetFieldID (env, cl, "i", "I");
389   (*env)->SetIntField (env, jr, fl, r->i);
390   fl = (*env)->GetFieldID (env, cl, "i", "Z");
391   (*env)->SetBooleanField (env, jr, fl, r->b);
392   guestfs_free_int_bool (r);
393   return jr;
394 }
395
396 JNIEXPORT jobjectArray JNICALL
397 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlist
398   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
399 {
400   guestfs_h *g = (guestfs_h *) (long) jg;
401   jobjectArray jr;
402   jclass cl;
403   jfieldID fl;
404   jobject jfl;
405   struct guestfs_lvm_pv_list *r;
406   const char *val;
407   int i;
408
409   val = (*env)->GetStringUTFChars (env, jval, NULL);
410   r = guestfs_test0rpvlist (g, val);
411   (*env)->ReleaseStringUTFChars (env, jval, val);
412   if (r == NULL) {
413     throw_exception (env, guestfs_last_error (g));
414     return NULL;
415   }
416   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
417   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
418   for (i = 0; i < r->len; ++i) {
419     jfl = (*env)->AllocObject (env, cl);
420     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
421     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
422     {
423       char s[33];
424       memcpy (s, r->val[i].pv_uuid, 32);
425       s[32] = 0;
426       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
427       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
428     }
429     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
430     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
431     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
432     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
433     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
434     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
435     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
436     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
437     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
438     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
439     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
440     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
441     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
442     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
443     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
444     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
445     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
446     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
447     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
448     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
449     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
450     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
451     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
452     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
453     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
454   }
455   guestfs_free_lvm_pv_list (r);
456   return jr;
457 }
458
459 JNIEXPORT jobjectArray JNICALL
460 Java_com_redhat_et_libguestfs_GuestFS__1test0rpvlisterr
461   (JNIEnv *env, jobject obj, jlong jg)
462 {
463   guestfs_h *g = (guestfs_h *) (long) jg;
464   jobjectArray jr;
465   jclass cl;
466   jfieldID fl;
467   jobject jfl;
468   struct guestfs_lvm_pv_list *r;
469   int i;
470
471   r = guestfs_test0rpvlisterr (g);
472   if (r == NULL) {
473     throw_exception (env, guestfs_last_error (g));
474     return NULL;
475   }
476   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
477   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
478   for (i = 0; i < r->len; ++i) {
479     jfl = (*env)->AllocObject (env, cl);
480     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
481     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
482     {
483       char s[33];
484       memcpy (s, r->val[i].pv_uuid, 32);
485       s[32] = 0;
486       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
487       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
488     }
489     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
490     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
491     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
492     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
493     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
494     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
495     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
496     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
497     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
498     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
499     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
500     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
501     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
502     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
503     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
504     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
505     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
506     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
507     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
508     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
509     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
510     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
511     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
512     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
513     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
514   }
515   guestfs_free_lvm_pv_list (r);
516   return jr;
517 }
518
519 JNIEXPORT jobjectArray JNICALL
520 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglist
521   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
522 {
523   guestfs_h *g = (guestfs_h *) (long) jg;
524   jobjectArray jr;
525   jclass cl;
526   jfieldID fl;
527   jobject jfl;
528   struct guestfs_lvm_vg_list *r;
529   const char *val;
530   int i;
531
532   val = (*env)->GetStringUTFChars (env, jval, NULL);
533   r = guestfs_test0rvglist (g, val);
534   (*env)->ReleaseStringUTFChars (env, jval, val);
535   if (r == NULL) {
536     throw_exception (env, guestfs_last_error (g));
537     return NULL;
538   }
539   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
540   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
541   for (i = 0; i < r->len; ++i) {
542     jfl = (*env)->AllocObject (env, cl);
543     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
544     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
545     {
546       char s[33];
547       memcpy (s, r->val[i].vg_uuid, 32);
548       s[32] = 0;
549       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
550       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
551     }
552     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
553     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
554     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
555     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
556     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
557     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
558     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
559     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
560     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
561     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
562     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
563     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
564     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
565     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
566     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
567     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
568     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
569     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
570     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
571     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
572     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
573     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
574     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
575     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
576     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
577     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
578     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
579     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
580     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
581     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
582     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
583     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
584     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
585     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
586     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
587   }
588   guestfs_free_lvm_vg_list (r);
589   return jr;
590 }
591
592 JNIEXPORT jobjectArray JNICALL
593 Java_com_redhat_et_libguestfs_GuestFS__1test0rvglisterr
594   (JNIEnv *env, jobject obj, jlong jg)
595 {
596   guestfs_h *g = (guestfs_h *) (long) jg;
597   jobjectArray jr;
598   jclass cl;
599   jfieldID fl;
600   jobject jfl;
601   struct guestfs_lvm_vg_list *r;
602   int i;
603
604   r = guestfs_test0rvglisterr (g);
605   if (r == NULL) {
606     throw_exception (env, guestfs_last_error (g));
607     return NULL;
608   }
609   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
610   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
611   for (i = 0; i < r->len; ++i) {
612     jfl = (*env)->AllocObject (env, cl);
613     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
614     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
615     {
616       char s[33];
617       memcpy (s, r->val[i].vg_uuid, 32);
618       s[32] = 0;
619       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
620       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
621     }
622     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
623     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
624     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
625     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
626     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
627     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
628     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
629     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
630     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
631     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
632     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
633     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
634     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
635     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
636     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
637     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
638     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
639     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
640     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
641     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
642     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
643     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
644     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
645     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
646     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
647     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
648     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
649     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
650     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
651     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
652     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
653     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
654     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
655     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
656     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
657   }
658   guestfs_free_lvm_vg_list (r);
659   return jr;
660 }
661
662 JNIEXPORT jobjectArray JNICALL
663 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlist
664   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
665 {
666   guestfs_h *g = (guestfs_h *) (long) jg;
667   jobjectArray jr;
668   jclass cl;
669   jfieldID fl;
670   jobject jfl;
671   struct guestfs_lvm_lv_list *r;
672   const char *val;
673   int i;
674
675   val = (*env)->GetStringUTFChars (env, jval, NULL);
676   r = guestfs_test0rlvlist (g, val);
677   (*env)->ReleaseStringUTFChars (env, jval, val);
678   if (r == NULL) {
679     throw_exception (env, guestfs_last_error (g));
680     return NULL;
681   }
682   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
683   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
684   for (i = 0; i < r->len; ++i) {
685     jfl = (*env)->AllocObject (env, cl);
686     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
687     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
688     {
689       char s[33];
690       memcpy (s, r->val[i].lv_uuid, 32);
691       s[32] = 0;
692       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
693       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
694     }
695     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
696     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
697     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
698     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
699     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
700     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
701     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
702     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
703     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
704     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
705     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
706     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
707     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
708     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
709     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
710     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
711     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
712     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
713     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
714     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
715     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
716     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
717     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
718     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
719     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
720     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
721     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
722     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
723     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
724   }
725   guestfs_free_lvm_lv_list (r);
726   return jr;
727 }
728
729 JNIEXPORT jobjectArray JNICALL
730 Java_com_redhat_et_libguestfs_GuestFS__1test0rlvlisterr
731   (JNIEnv *env, jobject obj, jlong jg)
732 {
733   guestfs_h *g = (guestfs_h *) (long) jg;
734   jobjectArray jr;
735   jclass cl;
736   jfieldID fl;
737   jobject jfl;
738   struct guestfs_lvm_lv_list *r;
739   int i;
740
741   r = guestfs_test0rlvlisterr (g);
742   if (r == NULL) {
743     throw_exception (env, guestfs_last_error (g));
744     return NULL;
745   }
746   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
747   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
748   for (i = 0; i < r->len; ++i) {
749     jfl = (*env)->AllocObject (env, cl);
750     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
751     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
752     {
753       char s[33];
754       memcpy (s, r->val[i].lv_uuid, 32);
755       s[32] = 0;
756       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
757       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
758     }
759     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
760     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
761     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
762     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
763     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
764     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
765     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
766     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
767     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
768     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
769     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
770     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
771     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
772     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
773     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
774     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
775     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
776     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
777     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
778     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
779     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
780     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
781     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
782     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
783     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
784     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
785     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
786     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
787     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
788   }
789   guestfs_free_lvm_lv_list (r);
790   return jr;
791 }
792
793 JNIEXPORT jobject JNICALL
794 Java_com_redhat_et_libguestfs_GuestFS__1test0rstat
795   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
796 {
797   guestfs_h *g = (guestfs_h *) (long) jg;
798   jobject jr;
799   jclass cl;
800   jfieldID fl;
801   struct guestfs_stat *r;
802   const char *val;
803
804   val = (*env)->GetStringUTFChars (env, jval, NULL);
805   r = guestfs_test0rstat (g, val);
806   (*env)->ReleaseStringUTFChars (env, jval, val);
807   if (r == NULL) {
808     throw_exception (env, guestfs_last_error (g));
809     return NULL;
810   }
811   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
812   jr = (*env)->AllocObject (env, cl);
813   fl = (*env)->GetFieldID (env, cl, "dev", "J");
814   (*env)->SetLongField (env, jr, fl, r->dev);
815   fl = (*env)->GetFieldID (env, cl, "ino", "J");
816   (*env)->SetLongField (env, jr, fl, r->ino);
817   fl = (*env)->GetFieldID (env, cl, "mode", "J");
818   (*env)->SetLongField (env, jr, fl, r->mode);
819   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
820   (*env)->SetLongField (env, jr, fl, r->nlink);
821   fl = (*env)->GetFieldID (env, cl, "uid", "J");
822   (*env)->SetLongField (env, jr, fl, r->uid);
823   fl = (*env)->GetFieldID (env, cl, "gid", "J");
824   (*env)->SetLongField (env, jr, fl, r->gid);
825   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
826   (*env)->SetLongField (env, jr, fl, r->rdev);
827   fl = (*env)->GetFieldID (env, cl, "size", "J");
828   (*env)->SetLongField (env, jr, fl, r->size);
829   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
830   (*env)->SetLongField (env, jr, fl, r->blksize);
831   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
832   (*env)->SetLongField (env, jr, fl, r->blocks);
833   fl = (*env)->GetFieldID (env, cl, "atime", "J");
834   (*env)->SetLongField (env, jr, fl, r->atime);
835   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
836   (*env)->SetLongField (env, jr, fl, r->mtime);
837   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
838   (*env)->SetLongField (env, jr, fl, r->ctime);
839   free (r);
840   return jr;
841 }
842
843 JNIEXPORT jobject JNICALL
844 Java_com_redhat_et_libguestfs_GuestFS__1test0rstaterr
845   (JNIEnv *env, jobject obj, jlong jg)
846 {
847   guestfs_h *g = (guestfs_h *) (long) jg;
848   jobject jr;
849   jclass cl;
850   jfieldID fl;
851   struct guestfs_stat *r;
852
853   r = guestfs_test0rstaterr (g);
854   if (r == NULL) {
855     throw_exception (env, guestfs_last_error (g));
856     return NULL;
857   }
858   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
859   jr = (*env)->AllocObject (env, cl);
860   fl = (*env)->GetFieldID (env, cl, "dev", "J");
861   (*env)->SetLongField (env, jr, fl, r->dev);
862   fl = (*env)->GetFieldID (env, cl, "ino", "J");
863   (*env)->SetLongField (env, jr, fl, r->ino);
864   fl = (*env)->GetFieldID (env, cl, "mode", "J");
865   (*env)->SetLongField (env, jr, fl, r->mode);
866   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
867   (*env)->SetLongField (env, jr, fl, r->nlink);
868   fl = (*env)->GetFieldID (env, cl, "uid", "J");
869   (*env)->SetLongField (env, jr, fl, r->uid);
870   fl = (*env)->GetFieldID (env, cl, "gid", "J");
871   (*env)->SetLongField (env, jr, fl, r->gid);
872   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
873   (*env)->SetLongField (env, jr, fl, r->rdev);
874   fl = (*env)->GetFieldID (env, cl, "size", "J");
875   (*env)->SetLongField (env, jr, fl, r->size);
876   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
877   (*env)->SetLongField (env, jr, fl, r->blksize);
878   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
879   (*env)->SetLongField (env, jr, fl, r->blocks);
880   fl = (*env)->GetFieldID (env, cl, "atime", "J");
881   (*env)->SetLongField (env, jr, fl, r->atime);
882   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
883   (*env)->SetLongField (env, jr, fl, r->mtime);
884   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
885   (*env)->SetLongField (env, jr, fl, r->ctime);
886   free (r);
887   return jr;
888 }
889
890 JNIEXPORT jobject JNICALL
891 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfs
892   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
893 {
894   guestfs_h *g = (guestfs_h *) (long) jg;
895   jobject jr;
896   jclass cl;
897   jfieldID fl;
898   struct guestfs_statvfs *r;
899   const char *val;
900
901   val = (*env)->GetStringUTFChars (env, jval, NULL);
902   r = guestfs_test0rstatvfs (g, val);
903   (*env)->ReleaseStringUTFChars (env, jval, val);
904   if (r == NULL) {
905     throw_exception (env, guestfs_last_error (g));
906     return NULL;
907   }
908   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
909   jr = (*env)->AllocObject (env, cl);
910   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
911   (*env)->SetLongField (env, jr, fl, r->bsize);
912   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
913   (*env)->SetLongField (env, jr, fl, r->frsize);
914   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
915   (*env)->SetLongField (env, jr, fl, r->blocks);
916   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
917   (*env)->SetLongField (env, jr, fl, r->bfree);
918   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
919   (*env)->SetLongField (env, jr, fl, r->bavail);
920   fl = (*env)->GetFieldID (env, cl, "files", "J");
921   (*env)->SetLongField (env, jr, fl, r->files);
922   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
923   (*env)->SetLongField (env, jr, fl, r->ffree);
924   fl = (*env)->GetFieldID (env, cl, "favail", "J");
925   (*env)->SetLongField (env, jr, fl, r->favail);
926   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
927   (*env)->SetLongField (env, jr, fl, r->fsid);
928   fl = (*env)->GetFieldID (env, cl, "flag", "J");
929   (*env)->SetLongField (env, jr, fl, r->flag);
930   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
931   (*env)->SetLongField (env, jr, fl, r->namemax);
932   free (r);
933   return jr;
934 }
935
936 JNIEXPORT jobject JNICALL
937 Java_com_redhat_et_libguestfs_GuestFS__1test0rstatvfserr
938   (JNIEnv *env, jobject obj, jlong jg)
939 {
940   guestfs_h *g = (guestfs_h *) (long) jg;
941   jobject jr;
942   jclass cl;
943   jfieldID fl;
944   struct guestfs_statvfs *r;
945
946   r = guestfs_test0rstatvfserr (g);
947   if (r == NULL) {
948     throw_exception (env, guestfs_last_error (g));
949     return NULL;
950   }
951   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
952   jr = (*env)->AllocObject (env, cl);
953   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
954   (*env)->SetLongField (env, jr, fl, r->bsize);
955   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
956   (*env)->SetLongField (env, jr, fl, r->frsize);
957   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
958   (*env)->SetLongField (env, jr, fl, r->blocks);
959   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
960   (*env)->SetLongField (env, jr, fl, r->bfree);
961   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
962   (*env)->SetLongField (env, jr, fl, r->bavail);
963   fl = (*env)->GetFieldID (env, cl, "files", "J");
964   (*env)->SetLongField (env, jr, fl, r->files);
965   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
966   (*env)->SetLongField (env, jr, fl, r->ffree);
967   fl = (*env)->GetFieldID (env, cl, "favail", "J");
968   (*env)->SetLongField (env, jr, fl, r->favail);
969   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
970   (*env)->SetLongField (env, jr, fl, r->fsid);
971   fl = (*env)->GetFieldID (env, cl, "flag", "J");
972   (*env)->SetLongField (env, jr, fl, r->flag);
973   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
974   (*env)->SetLongField (env, jr, fl, r->namemax);
975   free (r);
976   return jr;
977 }
978
979 JNIEXPORT jobject JNICALL
980 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtable
981   (JNIEnv *env, jobject obj, jlong jg, jstring jval)
982 {
983   guestfs_h *g = (guestfs_h *) (long) jg;
984   char **r;
985   const char *val;
986
987   val = (*env)->GetStringUTFChars (env, jval, NULL);
988   r = guestfs_test0rhashtable (g, val);
989   (*env)->ReleaseStringUTFChars (env, jval, val);
990   if (r == NULL) {
991     throw_exception (env, guestfs_last_error (g));
992     return NULL;
993   }
994   throw_exception (env, "test0rhashtable: internal error: please let us know how to make a Java HashMap from JNI bindings!");
995   return NULL;
996 }
997
998 JNIEXPORT jobject JNICALL
999 Java_com_redhat_et_libguestfs_GuestFS__1test0rhashtableerr
1000   (JNIEnv *env, jobject obj, jlong jg)
1001 {
1002   guestfs_h *g = (guestfs_h *) (long) jg;
1003   char **r;
1004
1005   r = guestfs_test0rhashtableerr (g);
1006   if (r == NULL) {
1007     throw_exception (env, guestfs_last_error (g));
1008     return NULL;
1009   }
1010   throw_exception (env, "test0rhashtableerr: internal error: please let us know how to make a Java HashMap from JNI bindings!");
1011   return NULL;
1012 }
1013
1014 JNIEXPORT void JNICALL
1015 Java_com_redhat_et_libguestfs_GuestFS__1launch
1016   (JNIEnv *env, jobject obj, jlong jg)
1017 {
1018   guestfs_h *g = (guestfs_h *) (long) jg;
1019   int r;
1020
1021   r = guestfs_launch (g);
1022   if (r == -1) {
1023     throw_exception (env, guestfs_last_error (g));
1024     return ;
1025   }
1026 }
1027
1028 JNIEXPORT void JNICALL
1029 Java_com_redhat_et_libguestfs_GuestFS__1wait_1ready
1030   (JNIEnv *env, jobject obj, jlong jg)
1031 {
1032   guestfs_h *g = (guestfs_h *) (long) jg;
1033   int r;
1034
1035   r = guestfs_wait_ready (g);
1036   if (r == -1) {
1037     throw_exception (env, guestfs_last_error (g));
1038     return ;
1039   }
1040 }
1041
1042 JNIEXPORT void JNICALL
1043 Java_com_redhat_et_libguestfs_GuestFS__1kill_1subprocess
1044   (JNIEnv *env, jobject obj, jlong jg)
1045 {
1046   guestfs_h *g = (guestfs_h *) (long) jg;
1047   int r;
1048
1049   r = guestfs_kill_subprocess (g);
1050   if (r == -1) {
1051     throw_exception (env, guestfs_last_error (g));
1052     return ;
1053   }
1054 }
1055
1056 JNIEXPORT void JNICALL
1057 Java_com_redhat_et_libguestfs_GuestFS__1add_1drive
1058   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1059 {
1060   guestfs_h *g = (guestfs_h *) (long) jg;
1061   int r;
1062   const char *filename;
1063
1064   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1065   r = guestfs_add_drive (g, filename);
1066   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1067   if (r == -1) {
1068     throw_exception (env, guestfs_last_error (g));
1069     return ;
1070   }
1071 }
1072
1073 JNIEXPORT void JNICALL
1074 Java_com_redhat_et_libguestfs_GuestFS__1add_1cdrom
1075   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename)
1076 {
1077   guestfs_h *g = (guestfs_h *) (long) jg;
1078   int r;
1079   const char *filename;
1080
1081   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
1082   r = guestfs_add_cdrom (g, filename);
1083   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
1084   if (r == -1) {
1085     throw_exception (env, guestfs_last_error (g));
1086     return ;
1087   }
1088 }
1089
1090 JNIEXPORT void JNICALL
1091 Java_com_redhat_et_libguestfs_GuestFS__1config
1092   (JNIEnv *env, jobject obj, jlong jg, jstring jqemuparam, jstring jqemuvalue)
1093 {
1094   guestfs_h *g = (guestfs_h *) (long) jg;
1095   int r;
1096   const char *qemuparam;
1097   const char *qemuvalue;
1098
1099   qemuparam = (*env)->GetStringUTFChars (env, jqemuparam, NULL);
1100   qemuvalue = (*env)->GetStringUTFChars (env, jqemuvalue, NULL);
1101   r = guestfs_config (g, qemuparam, qemuvalue);
1102   (*env)->ReleaseStringUTFChars (env, jqemuparam, qemuparam);
1103   (*env)->ReleaseStringUTFChars (env, jqemuvalue, qemuvalue);
1104   if (r == -1) {
1105     throw_exception (env, guestfs_last_error (g));
1106     return ;
1107   }
1108 }
1109
1110 JNIEXPORT void JNICALL
1111 Java_com_redhat_et_libguestfs_GuestFS__1set_1qemu
1112   (JNIEnv *env, jobject obj, jlong jg, jstring jqemu)
1113 {
1114   guestfs_h *g = (guestfs_h *) (long) jg;
1115   int r;
1116   const char *qemu;
1117
1118   qemu = (*env)->GetStringUTFChars (env, jqemu, NULL);
1119   r = guestfs_set_qemu (g, qemu);
1120   (*env)->ReleaseStringUTFChars (env, jqemu, qemu);
1121   if (r == -1) {
1122     throw_exception (env, guestfs_last_error (g));
1123     return ;
1124   }
1125 }
1126
1127 JNIEXPORT jstring JNICALL
1128 Java_com_redhat_et_libguestfs_GuestFS__1get_1qemu
1129   (JNIEnv *env, jobject obj, jlong jg)
1130 {
1131   guestfs_h *g = (guestfs_h *) (long) jg;
1132   const char *r;
1133
1134   r = guestfs_get_qemu (g);
1135   if (r == NULL) {
1136     throw_exception (env, guestfs_last_error (g));
1137     return NULL;
1138   }
1139   return (*env)->NewStringUTF (env, r);
1140 }
1141
1142 JNIEXPORT void JNICALL
1143 Java_com_redhat_et_libguestfs_GuestFS__1set_1path
1144   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1145 {
1146   guestfs_h *g = (guestfs_h *) (long) jg;
1147   int r;
1148   const char *path;
1149
1150   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1151   r = guestfs_set_path (g, path);
1152   (*env)->ReleaseStringUTFChars (env, jpath, path);
1153   if (r == -1) {
1154     throw_exception (env, guestfs_last_error (g));
1155     return ;
1156   }
1157 }
1158
1159 JNIEXPORT jstring JNICALL
1160 Java_com_redhat_et_libguestfs_GuestFS__1get_1path
1161   (JNIEnv *env, jobject obj, jlong jg)
1162 {
1163   guestfs_h *g = (guestfs_h *) (long) jg;
1164   const char *r;
1165
1166   r = guestfs_get_path (g);
1167   if (r == NULL) {
1168     throw_exception (env, guestfs_last_error (g));
1169     return NULL;
1170   }
1171   return (*env)->NewStringUTF (env, r);
1172 }
1173
1174 JNIEXPORT void JNICALL
1175 Java_com_redhat_et_libguestfs_GuestFS__1set_1append
1176   (JNIEnv *env, jobject obj, jlong jg, jstring jappend)
1177 {
1178   guestfs_h *g = (guestfs_h *) (long) jg;
1179   int r;
1180   const char *append;
1181
1182   append = (*env)->GetStringUTFChars (env, jappend, NULL);
1183   r = guestfs_set_append (g, append);
1184   (*env)->ReleaseStringUTFChars (env, jappend, append);
1185   if (r == -1) {
1186     throw_exception (env, guestfs_last_error (g));
1187     return ;
1188   }
1189 }
1190
1191 JNIEXPORT jstring JNICALL
1192 Java_com_redhat_et_libguestfs_GuestFS__1get_1append
1193   (JNIEnv *env, jobject obj, jlong jg)
1194 {
1195   guestfs_h *g = (guestfs_h *) (long) jg;
1196   const char *r;
1197
1198   r = guestfs_get_append (g);
1199   if (r == NULL) {
1200     throw_exception (env, guestfs_last_error (g));
1201     return NULL;
1202   }
1203   return (*env)->NewStringUTF (env, r);
1204 }
1205
1206 JNIEXPORT void JNICALL
1207 Java_com_redhat_et_libguestfs_GuestFS__1set_1autosync
1208   (JNIEnv *env, jobject obj, jlong jg, jboolean jautosync)
1209 {
1210   guestfs_h *g = (guestfs_h *) (long) jg;
1211   int r;
1212   int autosync;
1213
1214   autosync = jautosync;
1215   r = guestfs_set_autosync (g, autosync);
1216   if (r == -1) {
1217     throw_exception (env, guestfs_last_error (g));
1218     return ;
1219   }
1220 }
1221
1222 JNIEXPORT jboolean JNICALL
1223 Java_com_redhat_et_libguestfs_GuestFS__1get_1autosync
1224   (JNIEnv *env, jobject obj, jlong jg)
1225 {
1226   guestfs_h *g = (guestfs_h *) (long) jg;
1227   int r;
1228
1229   r = guestfs_get_autosync (g);
1230   if (r == -1) {
1231     throw_exception (env, guestfs_last_error (g));
1232     return 0;
1233   }
1234   return (jboolean) r;
1235 }
1236
1237 JNIEXPORT void JNICALL
1238 Java_com_redhat_et_libguestfs_GuestFS__1set_1verbose
1239   (JNIEnv *env, jobject obj, jlong jg, jboolean jverbose)
1240 {
1241   guestfs_h *g = (guestfs_h *) (long) jg;
1242   int r;
1243   int verbose;
1244
1245   verbose = jverbose;
1246   r = guestfs_set_verbose (g, verbose);
1247   if (r == -1) {
1248     throw_exception (env, guestfs_last_error (g));
1249     return ;
1250   }
1251 }
1252
1253 JNIEXPORT jboolean JNICALL
1254 Java_com_redhat_et_libguestfs_GuestFS__1get_1verbose
1255   (JNIEnv *env, jobject obj, jlong jg)
1256 {
1257   guestfs_h *g = (guestfs_h *) (long) jg;
1258   int r;
1259
1260   r = guestfs_get_verbose (g);
1261   if (r == -1) {
1262     throw_exception (env, guestfs_last_error (g));
1263     return 0;
1264   }
1265   return (jboolean) r;
1266 }
1267
1268 JNIEXPORT jboolean JNICALL
1269 Java_com_redhat_et_libguestfs_GuestFS__1is_1ready
1270   (JNIEnv *env, jobject obj, jlong jg)
1271 {
1272   guestfs_h *g = (guestfs_h *) (long) jg;
1273   int r;
1274
1275   r = guestfs_is_ready (g);
1276   if (r == -1) {
1277     throw_exception (env, guestfs_last_error (g));
1278     return 0;
1279   }
1280   return (jboolean) r;
1281 }
1282
1283 JNIEXPORT jboolean JNICALL
1284 Java_com_redhat_et_libguestfs_GuestFS__1is_1config
1285   (JNIEnv *env, jobject obj, jlong jg)
1286 {
1287   guestfs_h *g = (guestfs_h *) (long) jg;
1288   int r;
1289
1290   r = guestfs_is_config (g);
1291   if (r == -1) {
1292     throw_exception (env, guestfs_last_error (g));
1293     return 0;
1294   }
1295   return (jboolean) r;
1296 }
1297
1298 JNIEXPORT jboolean JNICALL
1299 Java_com_redhat_et_libguestfs_GuestFS__1is_1launching
1300   (JNIEnv *env, jobject obj, jlong jg)
1301 {
1302   guestfs_h *g = (guestfs_h *) (long) jg;
1303   int r;
1304
1305   r = guestfs_is_launching (g);
1306   if (r == -1) {
1307     throw_exception (env, guestfs_last_error (g));
1308     return 0;
1309   }
1310   return (jboolean) r;
1311 }
1312
1313 JNIEXPORT jboolean JNICALL
1314 Java_com_redhat_et_libguestfs_GuestFS__1is_1busy
1315   (JNIEnv *env, jobject obj, jlong jg)
1316 {
1317   guestfs_h *g = (guestfs_h *) (long) jg;
1318   int r;
1319
1320   r = guestfs_is_busy (g);
1321   if (r == -1) {
1322     throw_exception (env, guestfs_last_error (g));
1323     return 0;
1324   }
1325   return (jboolean) r;
1326 }
1327
1328 JNIEXPORT jint JNICALL
1329 Java_com_redhat_et_libguestfs_GuestFS__1get_1state
1330   (JNIEnv *env, jobject obj, jlong jg)
1331 {
1332   guestfs_h *g = (guestfs_h *) (long) jg;
1333   int r;
1334
1335   r = guestfs_get_state (g);
1336   if (r == -1) {
1337     throw_exception (env, guestfs_last_error (g));
1338     return 0;
1339   }
1340   return (jint) r;
1341 }
1342
1343 JNIEXPORT void JNICALL
1344 Java_com_redhat_et_libguestfs_GuestFS__1set_1busy
1345   (JNIEnv *env, jobject obj, jlong jg)
1346 {
1347   guestfs_h *g = (guestfs_h *) (long) jg;
1348   int r;
1349
1350   r = guestfs_set_busy (g);
1351   if (r == -1) {
1352     throw_exception (env, guestfs_last_error (g));
1353     return ;
1354   }
1355 }
1356
1357 JNIEXPORT void JNICALL
1358 Java_com_redhat_et_libguestfs_GuestFS__1set_1ready
1359   (JNIEnv *env, jobject obj, jlong jg)
1360 {
1361   guestfs_h *g = (guestfs_h *) (long) jg;
1362   int r;
1363
1364   r = guestfs_set_ready (g);
1365   if (r == -1) {
1366     throw_exception (env, guestfs_last_error (g));
1367     return ;
1368   }
1369 }
1370
1371 JNIEXPORT void JNICALL
1372 Java_com_redhat_et_libguestfs_GuestFS__1end_1busy
1373   (JNIEnv *env, jobject obj, jlong jg)
1374 {
1375   guestfs_h *g = (guestfs_h *) (long) jg;
1376   int r;
1377
1378   r = guestfs_end_busy (g);
1379   if (r == -1) {
1380     throw_exception (env, guestfs_last_error (g));
1381     return ;
1382   }
1383 }
1384
1385 JNIEXPORT void JNICALL
1386 Java_com_redhat_et_libguestfs_GuestFS__1mount
1387   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
1388 {
1389   guestfs_h *g = (guestfs_h *) (long) jg;
1390   int r;
1391   const char *device;
1392   const char *mountpoint;
1393
1394   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
1395   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
1396   r = guestfs_mount (g, device, mountpoint);
1397   (*env)->ReleaseStringUTFChars (env, jdevice, device);
1398   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
1399   if (r == -1) {
1400     throw_exception (env, guestfs_last_error (g));
1401     return ;
1402   }
1403 }
1404
1405 JNIEXPORT void JNICALL
1406 Java_com_redhat_et_libguestfs_GuestFS__1sync
1407   (JNIEnv *env, jobject obj, jlong jg)
1408 {
1409   guestfs_h *g = (guestfs_h *) (long) jg;
1410   int r;
1411
1412   r = guestfs_sync (g);
1413   if (r == -1) {
1414     throw_exception (env, guestfs_last_error (g));
1415     return ;
1416   }
1417 }
1418
1419 JNIEXPORT void JNICALL
1420 Java_com_redhat_et_libguestfs_GuestFS__1touch
1421   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1422 {
1423   guestfs_h *g = (guestfs_h *) (long) jg;
1424   int r;
1425   const char *path;
1426
1427   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1428   r = guestfs_touch (g, path);
1429   (*env)->ReleaseStringUTFChars (env, jpath, path);
1430   if (r == -1) {
1431     throw_exception (env, guestfs_last_error (g));
1432     return ;
1433   }
1434 }
1435
1436 JNIEXPORT jstring JNICALL
1437 Java_com_redhat_et_libguestfs_GuestFS__1cat
1438   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1439 {
1440   guestfs_h *g = (guestfs_h *) (long) jg;
1441   jstring jr;
1442   char *r;
1443   const char *path;
1444
1445   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1446   r = guestfs_cat (g, path);
1447   (*env)->ReleaseStringUTFChars (env, jpath, path);
1448   if (r == NULL) {
1449     throw_exception (env, guestfs_last_error (g));
1450     return NULL;
1451   }
1452   jr = (*env)->NewStringUTF (env, r);
1453   free (r);
1454   return jr;
1455 }
1456
1457 JNIEXPORT jstring JNICALL
1458 Java_com_redhat_et_libguestfs_GuestFS__1ll
1459   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1460 {
1461   guestfs_h *g = (guestfs_h *) (long) jg;
1462   jstring jr;
1463   char *r;
1464   const char *directory;
1465
1466   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1467   r = guestfs_ll (g, directory);
1468   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1469   if (r == NULL) {
1470     throw_exception (env, guestfs_last_error (g));
1471     return NULL;
1472   }
1473   jr = (*env)->NewStringUTF (env, r);
1474   free (r);
1475   return jr;
1476 }
1477
1478 JNIEXPORT jobjectArray JNICALL
1479 Java_com_redhat_et_libguestfs_GuestFS__1ls
1480   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory)
1481 {
1482   guestfs_h *g = (guestfs_h *) (long) jg;
1483   jobjectArray jr;
1484   int r_len;
1485   jclass cl;
1486   jstring jstr;
1487   char **r;
1488   const char *directory;
1489   int i;
1490
1491   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
1492   r = guestfs_ls (g, directory);
1493   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
1494   if (r == NULL) {
1495     throw_exception (env, guestfs_last_error (g));
1496     return NULL;
1497   }
1498   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1499   cl = (*env)->FindClass (env, "java/lang/String");
1500   jstr = (*env)->NewStringUTF (env, "");
1501   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1502   for (i = 0; i < r_len; ++i) {
1503     jstr = (*env)->NewStringUTF (env, r[i]);
1504     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1505     free (r[i]);
1506   }
1507   free (r);
1508   return jr;
1509 }
1510
1511 JNIEXPORT jobjectArray JNICALL
1512 Java_com_redhat_et_libguestfs_GuestFS__1list_1devices
1513   (JNIEnv *env, jobject obj, jlong jg)
1514 {
1515   guestfs_h *g = (guestfs_h *) (long) jg;
1516   jobjectArray jr;
1517   int r_len;
1518   jclass cl;
1519   jstring jstr;
1520   char **r;
1521   int i;
1522
1523   r = guestfs_list_devices (g);
1524   if (r == NULL) {
1525     throw_exception (env, guestfs_last_error (g));
1526     return NULL;
1527   }
1528   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1529   cl = (*env)->FindClass (env, "java/lang/String");
1530   jstr = (*env)->NewStringUTF (env, "");
1531   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1532   for (i = 0; i < r_len; ++i) {
1533     jstr = (*env)->NewStringUTF (env, r[i]);
1534     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1535     free (r[i]);
1536   }
1537   free (r);
1538   return jr;
1539 }
1540
1541 JNIEXPORT jobjectArray JNICALL
1542 Java_com_redhat_et_libguestfs_GuestFS__1list_1partitions
1543   (JNIEnv *env, jobject obj, jlong jg)
1544 {
1545   guestfs_h *g = (guestfs_h *) (long) jg;
1546   jobjectArray jr;
1547   int r_len;
1548   jclass cl;
1549   jstring jstr;
1550   char **r;
1551   int i;
1552
1553   r = guestfs_list_partitions (g);
1554   if (r == NULL) {
1555     throw_exception (env, guestfs_last_error (g));
1556     return NULL;
1557   }
1558   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1559   cl = (*env)->FindClass (env, "java/lang/String");
1560   jstr = (*env)->NewStringUTF (env, "");
1561   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1562   for (i = 0; i < r_len; ++i) {
1563     jstr = (*env)->NewStringUTF (env, r[i]);
1564     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1565     free (r[i]);
1566   }
1567   free (r);
1568   return jr;
1569 }
1570
1571 JNIEXPORT jobjectArray JNICALL
1572 Java_com_redhat_et_libguestfs_GuestFS__1pvs
1573   (JNIEnv *env, jobject obj, jlong jg)
1574 {
1575   guestfs_h *g = (guestfs_h *) (long) jg;
1576   jobjectArray jr;
1577   int r_len;
1578   jclass cl;
1579   jstring jstr;
1580   char **r;
1581   int i;
1582
1583   r = guestfs_pvs (g);
1584   if (r == NULL) {
1585     throw_exception (env, guestfs_last_error (g));
1586     return NULL;
1587   }
1588   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1589   cl = (*env)->FindClass (env, "java/lang/String");
1590   jstr = (*env)->NewStringUTF (env, "");
1591   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1592   for (i = 0; i < r_len; ++i) {
1593     jstr = (*env)->NewStringUTF (env, r[i]);
1594     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1595     free (r[i]);
1596   }
1597   free (r);
1598   return jr;
1599 }
1600
1601 JNIEXPORT jobjectArray JNICALL
1602 Java_com_redhat_et_libguestfs_GuestFS__1vgs
1603   (JNIEnv *env, jobject obj, jlong jg)
1604 {
1605   guestfs_h *g = (guestfs_h *) (long) jg;
1606   jobjectArray jr;
1607   int r_len;
1608   jclass cl;
1609   jstring jstr;
1610   char **r;
1611   int i;
1612
1613   r = guestfs_vgs (g);
1614   if (r == NULL) {
1615     throw_exception (env, guestfs_last_error (g));
1616     return NULL;
1617   }
1618   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1619   cl = (*env)->FindClass (env, "java/lang/String");
1620   jstr = (*env)->NewStringUTF (env, "");
1621   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1622   for (i = 0; i < r_len; ++i) {
1623     jstr = (*env)->NewStringUTF (env, r[i]);
1624     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1625     free (r[i]);
1626   }
1627   free (r);
1628   return jr;
1629 }
1630
1631 JNIEXPORT jobjectArray JNICALL
1632 Java_com_redhat_et_libguestfs_GuestFS__1lvs
1633   (JNIEnv *env, jobject obj, jlong jg)
1634 {
1635   guestfs_h *g = (guestfs_h *) (long) jg;
1636   jobjectArray jr;
1637   int r_len;
1638   jclass cl;
1639   jstring jstr;
1640   char **r;
1641   int i;
1642
1643   r = guestfs_lvs (g);
1644   if (r == NULL) {
1645     throw_exception (env, guestfs_last_error (g));
1646     return NULL;
1647   }
1648   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1649   cl = (*env)->FindClass (env, "java/lang/String");
1650   jstr = (*env)->NewStringUTF (env, "");
1651   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1652   for (i = 0; i < r_len; ++i) {
1653     jstr = (*env)->NewStringUTF (env, r[i]);
1654     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1655     free (r[i]);
1656   }
1657   free (r);
1658   return jr;
1659 }
1660
1661 JNIEXPORT jobjectArray JNICALL
1662 Java_com_redhat_et_libguestfs_GuestFS__1pvs_1full
1663   (JNIEnv *env, jobject obj, jlong jg)
1664 {
1665   guestfs_h *g = (guestfs_h *) (long) jg;
1666   jobjectArray jr;
1667   jclass cl;
1668   jfieldID fl;
1669   jobject jfl;
1670   struct guestfs_lvm_pv_list *r;
1671   int i;
1672
1673   r = guestfs_pvs_full (g);
1674   if (r == NULL) {
1675     throw_exception (env, guestfs_last_error (g));
1676     return NULL;
1677   }
1678   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/PV");
1679   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1680   for (i = 0; i < r->len; ++i) {
1681     jfl = (*env)->AllocObject (env, cl);
1682     fl = (*env)->GetFieldID (env, cl, "pv_name", "Ljava/lang/String;");
1683     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_name));
1684     {
1685       char s[33];
1686       memcpy (s, r->val[i].pv_uuid, 32);
1687       s[32] = 0;
1688       fl = (*env)->GetFieldID (env, cl, "pv_uuid", "Ljava/lang/String;");
1689       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1690     }
1691     fl = (*env)->GetFieldID (env, cl, "pv_fmt", "Ljava/lang/String;");
1692     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_fmt));
1693     fl = (*env)->GetFieldID (env, cl, "pv_size", "J");
1694     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_size);
1695     fl = (*env)->GetFieldID (env, cl, "dev_size", "J");
1696     (*env)->SetLongField (env, jfl, fl, r->val[i].dev_size);
1697     fl = (*env)->GetFieldID (env, cl, "pv_free", "J");
1698     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_free);
1699     fl = (*env)->GetFieldID (env, cl, "pv_used", "J");
1700     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_used);
1701     fl = (*env)->GetFieldID (env, cl, "pv_attr", "Ljava/lang/String;");
1702     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_attr));
1703     fl = (*env)->GetFieldID (env, cl, "pv_pe_count", "J");
1704     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_count);
1705     fl = (*env)->GetFieldID (env, cl, "pv_pe_alloc_count", "J");
1706     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_pe_alloc_count);
1707     fl = (*env)->GetFieldID (env, cl, "pv_tags", "Ljava/lang/String;");
1708     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].pv_tags));
1709     fl = (*env)->GetFieldID (env, cl, "pe_start", "J");
1710     (*env)->SetLongField (env, jfl, fl, r->val[i].pe_start);
1711     fl = (*env)->GetFieldID (env, cl, "pv_mda_count", "J");
1712     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_count);
1713     fl = (*env)->GetFieldID (env, cl, "pv_mda_free", "J");
1714     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_mda_free);
1715     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1716   }
1717   guestfs_free_lvm_pv_list (r);
1718   return jr;
1719 }
1720
1721 JNIEXPORT jobjectArray JNICALL
1722 Java_com_redhat_et_libguestfs_GuestFS__1vgs_1full
1723   (JNIEnv *env, jobject obj, jlong jg)
1724 {
1725   guestfs_h *g = (guestfs_h *) (long) jg;
1726   jobjectArray jr;
1727   jclass cl;
1728   jfieldID fl;
1729   jobject jfl;
1730   struct guestfs_lvm_vg_list *r;
1731   int i;
1732
1733   r = guestfs_vgs_full (g);
1734   if (r == NULL) {
1735     throw_exception (env, guestfs_last_error (g));
1736     return NULL;
1737   }
1738   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/VG");
1739   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1740   for (i = 0; i < r->len; ++i) {
1741     jfl = (*env)->AllocObject (env, cl);
1742     fl = (*env)->GetFieldID (env, cl, "vg_name", "Ljava/lang/String;");
1743     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_name));
1744     {
1745       char s[33];
1746       memcpy (s, r->val[i].vg_uuid, 32);
1747       s[32] = 0;
1748       fl = (*env)->GetFieldID (env, cl, "vg_uuid", "Ljava/lang/String;");
1749       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1750     }
1751     fl = (*env)->GetFieldID (env, cl, "vg_fmt", "Ljava/lang/String;");
1752     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_fmt));
1753     fl = (*env)->GetFieldID (env, cl, "vg_attr", "Ljava/lang/String;");
1754     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_attr));
1755     fl = (*env)->GetFieldID (env, cl, "vg_size", "J");
1756     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_size);
1757     fl = (*env)->GetFieldID (env, cl, "vg_free", "J");
1758     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free);
1759     fl = (*env)->GetFieldID (env, cl, "vg_sysid", "Ljava/lang/String;");
1760     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_sysid));
1761     fl = (*env)->GetFieldID (env, cl, "vg_extent_size", "J");
1762     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_size);
1763     fl = (*env)->GetFieldID (env, cl, "vg_extent_count", "J");
1764     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_extent_count);
1765     fl = (*env)->GetFieldID (env, cl, "vg_free_count", "J");
1766     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_free_count);
1767     fl = (*env)->GetFieldID (env, cl, "max_lv", "J");
1768     (*env)->SetLongField (env, jfl, fl, r->val[i].max_lv);
1769     fl = (*env)->GetFieldID (env, cl, "max_pv", "J");
1770     (*env)->SetLongField (env, jfl, fl, r->val[i].max_pv);
1771     fl = (*env)->GetFieldID (env, cl, "pv_count", "J");
1772     (*env)->SetLongField (env, jfl, fl, r->val[i].pv_count);
1773     fl = (*env)->GetFieldID (env, cl, "lv_count", "J");
1774     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_count);
1775     fl = (*env)->GetFieldID (env, cl, "snap_count", "J");
1776     (*env)->SetLongField (env, jfl, fl, r->val[i].snap_count);
1777     fl = (*env)->GetFieldID (env, cl, "vg_seqno", "J");
1778     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_seqno);
1779     fl = (*env)->GetFieldID (env, cl, "vg_tags", "Ljava/lang/String;");
1780     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].vg_tags));
1781     fl = (*env)->GetFieldID (env, cl, "vg_mda_count", "J");
1782     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_count);
1783     fl = (*env)->GetFieldID (env, cl, "vg_mda_free", "J");
1784     (*env)->SetLongField (env, jfl, fl, r->val[i].vg_mda_free);
1785     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1786   }
1787   guestfs_free_lvm_vg_list (r);
1788   return jr;
1789 }
1790
1791 JNIEXPORT jobjectArray JNICALL
1792 Java_com_redhat_et_libguestfs_GuestFS__1lvs_1full
1793   (JNIEnv *env, jobject obj, jlong jg)
1794 {
1795   guestfs_h *g = (guestfs_h *) (long) jg;
1796   jobjectArray jr;
1797   jclass cl;
1798   jfieldID fl;
1799   jobject jfl;
1800   struct guestfs_lvm_lv_list *r;
1801   int i;
1802
1803   r = guestfs_lvs_full (g);
1804   if (r == NULL) {
1805     throw_exception (env, guestfs_last_error (g));
1806     return NULL;
1807   }
1808   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/LV");
1809   jr = (*env)->NewObjectArray (env, r->len, cl, NULL);
1810   for (i = 0; i < r->len; ++i) {
1811     jfl = (*env)->AllocObject (env, cl);
1812     fl = (*env)->GetFieldID (env, cl, "lv_name", "Ljava/lang/String;");
1813     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_name));
1814     {
1815       char s[33];
1816       memcpy (s, r->val[i].lv_uuid, 32);
1817       s[32] = 0;
1818       fl = (*env)->GetFieldID (env, cl, "lv_uuid", "Ljava/lang/String;");
1819       (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, s));
1820     }
1821     fl = (*env)->GetFieldID (env, cl, "lv_attr", "Ljava/lang/String;");
1822     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_attr));
1823     fl = (*env)->GetFieldID (env, cl, "lv_major", "J");
1824     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_major);
1825     fl = (*env)->GetFieldID (env, cl, "lv_minor", "J");
1826     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_minor);
1827     fl = (*env)->GetFieldID (env, cl, "lv_kernel_major", "J");
1828     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_major);
1829     fl = (*env)->GetFieldID (env, cl, "lv_kernel_minor", "J");
1830     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_kernel_minor);
1831     fl = (*env)->GetFieldID (env, cl, "lv_size", "J");
1832     (*env)->SetLongField (env, jfl, fl, r->val[i].lv_size);
1833     fl = (*env)->GetFieldID (env, cl, "seg_count", "J");
1834     (*env)->SetLongField (env, jfl, fl, r->val[i].seg_count);
1835     fl = (*env)->GetFieldID (env, cl, "origin", "Ljava/lang/String;");
1836     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].origin));
1837     fl = (*env)->GetFieldID (env, cl, "snap_percent", "F");
1838     (*env)->SetFloatField (env, jfl, fl, r->val[i].snap_percent);
1839     fl = (*env)->GetFieldID (env, cl, "copy_percent", "F");
1840     (*env)->SetFloatField (env, jfl, fl, r->val[i].copy_percent);
1841     fl = (*env)->GetFieldID (env, cl, "move_pv", "Ljava/lang/String;");
1842     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].move_pv));
1843     fl = (*env)->GetFieldID (env, cl, "lv_tags", "Ljava/lang/String;");
1844     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].lv_tags));
1845     fl = (*env)->GetFieldID (env, cl, "mirror_log", "Ljava/lang/String;");
1846     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].mirror_log));
1847     fl = (*env)->GetFieldID (env, cl, "modules", "Ljava/lang/String;");
1848     (*env)->SetObjectField (env, jfl, fl, (*env)->NewStringUTF (env, r->val[i].modules));
1849     (*env)->SetObjectArrayElement (env, jfl, i, jfl);
1850   }
1851   guestfs_free_lvm_lv_list (r);
1852   return jr;
1853 }
1854
1855 JNIEXPORT jobjectArray JNICALL
1856 Java_com_redhat_et_libguestfs_GuestFS__1read_1lines
1857   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1858 {
1859   guestfs_h *g = (guestfs_h *) (long) jg;
1860   jobjectArray jr;
1861   int r_len;
1862   jclass cl;
1863   jstring jstr;
1864   char **r;
1865   const char *path;
1866   int i;
1867
1868   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1869   r = guestfs_read_lines (g, path);
1870   (*env)->ReleaseStringUTFChars (env, jpath, path);
1871   if (r == NULL) {
1872     throw_exception (env, guestfs_last_error (g));
1873     return NULL;
1874   }
1875   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
1876   cl = (*env)->FindClass (env, "java/lang/String");
1877   jstr = (*env)->NewStringUTF (env, "");
1878   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
1879   for (i = 0; i < r_len; ++i) {
1880     jstr = (*env)->NewStringUTF (env, r[i]);
1881     (*env)->SetObjectArrayElement (env, jr, i, jstr);
1882     free (r[i]);
1883   }
1884   free (r);
1885   return jr;
1886 }
1887
1888 JNIEXPORT void JNICALL
1889 Java_com_redhat_et_libguestfs_GuestFS__1aug_1init
1890   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jint jflags)
1891 {
1892   guestfs_h *g = (guestfs_h *) (long) jg;
1893   int r;
1894   const char *root;
1895   int flags;
1896
1897   root = (*env)->GetStringUTFChars (env, jroot, NULL);
1898   flags = jflags;
1899   r = guestfs_aug_init (g, root, flags);
1900   (*env)->ReleaseStringUTFChars (env, jroot, root);
1901   if (r == -1) {
1902     throw_exception (env, guestfs_last_error (g));
1903     return ;
1904   }
1905 }
1906
1907 JNIEXPORT void JNICALL
1908 Java_com_redhat_et_libguestfs_GuestFS__1aug_1close
1909   (JNIEnv *env, jobject obj, jlong jg)
1910 {
1911   guestfs_h *g = (guestfs_h *) (long) jg;
1912   int r;
1913
1914   r = guestfs_aug_close (g);
1915   if (r == -1) {
1916     throw_exception (env, guestfs_last_error (g));
1917     return ;
1918   }
1919 }
1920
1921 JNIEXPORT jint JNICALL
1922 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defvar
1923   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr)
1924 {
1925   guestfs_h *g = (guestfs_h *) (long) jg;
1926   int r;
1927   const char *name;
1928   const char *expr;
1929
1930   name = (*env)->GetStringUTFChars (env, jname, NULL);
1931   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
1932   r = guestfs_aug_defvar (g, name, expr);
1933   (*env)->ReleaseStringUTFChars (env, jname, name);
1934   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1935   if (r == -1) {
1936     throw_exception (env, guestfs_last_error (g));
1937     return 0;
1938   }
1939   return (jint) r;
1940 }
1941
1942 JNIEXPORT jobject JNICALL
1943 Java_com_redhat_et_libguestfs_GuestFS__1aug_1defnode
1944   (JNIEnv *env, jobject obj, jlong jg, jstring jname, jstring jexpr, jstring jval)
1945 {
1946   guestfs_h *g = (guestfs_h *) (long) jg;
1947   jobject jr;
1948   jclass cl;
1949   jfieldID fl;
1950   struct guestfs_int_bool *r;
1951   const char *name;
1952   const char *expr;
1953   const char *val;
1954
1955   name = (*env)->GetStringUTFChars (env, jname, NULL);
1956   expr = (*env)->GetStringUTFChars (env, jexpr, NULL);
1957   val = (*env)->GetStringUTFChars (env, jval, NULL);
1958   r = guestfs_aug_defnode (g, name, expr, val);
1959   (*env)->ReleaseStringUTFChars (env, jname, name);
1960   (*env)->ReleaseStringUTFChars (env, jexpr, expr);
1961   (*env)->ReleaseStringUTFChars (env, jval, val);
1962   if (r == NULL) {
1963     throw_exception (env, guestfs_last_error (g));
1964     return NULL;
1965   }
1966   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/IntBool");
1967   jr = (*env)->AllocObject (env, cl);
1968   fl = (*env)->GetFieldID (env, cl, "i", "I");
1969   (*env)->SetIntField (env, jr, fl, r->i);
1970   fl = (*env)->GetFieldID (env, cl, "i", "Z");
1971   (*env)->SetBooleanField (env, jr, fl, r->b);
1972   guestfs_free_int_bool (r);
1973   return jr;
1974 }
1975
1976 JNIEXPORT jstring JNICALL
1977 Java_com_redhat_et_libguestfs_GuestFS__1aug_1get
1978   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
1979 {
1980   guestfs_h *g = (guestfs_h *) (long) jg;
1981   jstring jr;
1982   char *r;
1983   const char *path;
1984
1985   path = (*env)->GetStringUTFChars (env, jpath, NULL);
1986   r = guestfs_aug_get (g, path);
1987   (*env)->ReleaseStringUTFChars (env, jpath, path);
1988   if (r == NULL) {
1989     throw_exception (env, guestfs_last_error (g));
1990     return NULL;
1991   }
1992   jr = (*env)->NewStringUTF (env, r);
1993   free (r);
1994   return jr;
1995 }
1996
1997 JNIEXPORT void JNICALL
1998 Java_com_redhat_et_libguestfs_GuestFS__1aug_1set
1999   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jval)
2000 {
2001   guestfs_h *g = (guestfs_h *) (long) jg;
2002   int r;
2003   const char *path;
2004   const char *val;
2005
2006   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2007   val = (*env)->GetStringUTFChars (env, jval, NULL);
2008   r = guestfs_aug_set (g, path, val);
2009   (*env)->ReleaseStringUTFChars (env, jpath, path);
2010   (*env)->ReleaseStringUTFChars (env, jval, val);
2011   if (r == -1) {
2012     throw_exception (env, guestfs_last_error (g));
2013     return ;
2014   }
2015 }
2016
2017 JNIEXPORT void JNICALL
2018 Java_com_redhat_et_libguestfs_GuestFS__1aug_1insert
2019   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jlabel, jboolean jbefore)
2020 {
2021   guestfs_h *g = (guestfs_h *) (long) jg;
2022   int r;
2023   const char *path;
2024   const char *label;
2025   int before;
2026
2027   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2028   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
2029   before = jbefore;
2030   r = guestfs_aug_insert (g, path, label, before);
2031   (*env)->ReleaseStringUTFChars (env, jpath, path);
2032   (*env)->ReleaseStringUTFChars (env, jlabel, label);
2033   if (r == -1) {
2034     throw_exception (env, guestfs_last_error (g));
2035     return ;
2036   }
2037 }
2038
2039 JNIEXPORT jint JNICALL
2040 Java_com_redhat_et_libguestfs_GuestFS__1aug_1rm
2041   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2042 {
2043   guestfs_h *g = (guestfs_h *) (long) jg;
2044   int r;
2045   const char *path;
2046
2047   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2048   r = guestfs_aug_rm (g, path);
2049   (*env)->ReleaseStringUTFChars (env, jpath, path);
2050   if (r == -1) {
2051     throw_exception (env, guestfs_last_error (g));
2052     return 0;
2053   }
2054   return (jint) r;
2055 }
2056
2057 JNIEXPORT void JNICALL
2058 Java_com_redhat_et_libguestfs_GuestFS__1aug_1mv
2059   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
2060 {
2061   guestfs_h *g = (guestfs_h *) (long) jg;
2062   int r;
2063   const char *src;
2064   const char *dest;
2065
2066   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
2067   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
2068   r = guestfs_aug_mv (g, src, dest);
2069   (*env)->ReleaseStringUTFChars (env, jsrc, src);
2070   (*env)->ReleaseStringUTFChars (env, jdest, dest);
2071   if (r == -1) {
2072     throw_exception (env, guestfs_last_error (g));
2073     return ;
2074   }
2075 }
2076
2077 JNIEXPORT jobjectArray JNICALL
2078 Java_com_redhat_et_libguestfs_GuestFS__1aug_1match
2079   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2080 {
2081   guestfs_h *g = (guestfs_h *) (long) jg;
2082   jobjectArray jr;
2083   int r_len;
2084   jclass cl;
2085   jstring jstr;
2086   char **r;
2087   const char *path;
2088   int i;
2089
2090   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2091   r = guestfs_aug_match (g, path);
2092   (*env)->ReleaseStringUTFChars (env, jpath, path);
2093   if (r == NULL) {
2094     throw_exception (env, guestfs_last_error (g));
2095     return NULL;
2096   }
2097   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2098   cl = (*env)->FindClass (env, "java/lang/String");
2099   jstr = (*env)->NewStringUTF (env, "");
2100   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2101   for (i = 0; i < r_len; ++i) {
2102     jstr = (*env)->NewStringUTF (env, r[i]);
2103     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2104     free (r[i]);
2105   }
2106   free (r);
2107   return jr;
2108 }
2109
2110 JNIEXPORT void JNICALL
2111 Java_com_redhat_et_libguestfs_GuestFS__1aug_1save
2112   (JNIEnv *env, jobject obj, jlong jg)
2113 {
2114   guestfs_h *g = (guestfs_h *) (long) jg;
2115   int r;
2116
2117   r = guestfs_aug_save (g);
2118   if (r == -1) {
2119     throw_exception (env, guestfs_last_error (g));
2120     return ;
2121   }
2122 }
2123
2124 JNIEXPORT void JNICALL
2125 Java_com_redhat_et_libguestfs_GuestFS__1aug_1load
2126   (JNIEnv *env, jobject obj, jlong jg)
2127 {
2128   guestfs_h *g = (guestfs_h *) (long) jg;
2129   int r;
2130
2131   r = guestfs_aug_load (g);
2132   if (r == -1) {
2133     throw_exception (env, guestfs_last_error (g));
2134     return ;
2135   }
2136 }
2137
2138 JNIEXPORT jobjectArray JNICALL
2139 Java_com_redhat_et_libguestfs_GuestFS__1aug_1ls
2140   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2141 {
2142   guestfs_h *g = (guestfs_h *) (long) jg;
2143   jobjectArray jr;
2144   int r_len;
2145   jclass cl;
2146   jstring jstr;
2147   char **r;
2148   const char *path;
2149   int i;
2150
2151   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2152   r = guestfs_aug_ls (g, path);
2153   (*env)->ReleaseStringUTFChars (env, jpath, path);
2154   if (r == NULL) {
2155     throw_exception (env, guestfs_last_error (g));
2156     return NULL;
2157   }
2158   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2159   cl = (*env)->FindClass (env, "java/lang/String");
2160   jstr = (*env)->NewStringUTF (env, "");
2161   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2162   for (i = 0; i < r_len; ++i) {
2163     jstr = (*env)->NewStringUTF (env, r[i]);
2164     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2165     free (r[i]);
2166   }
2167   free (r);
2168   return jr;
2169 }
2170
2171 JNIEXPORT void JNICALL
2172 Java_com_redhat_et_libguestfs_GuestFS__1rm
2173   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2174 {
2175   guestfs_h *g = (guestfs_h *) (long) jg;
2176   int r;
2177   const char *path;
2178
2179   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2180   r = guestfs_rm (g, path);
2181   (*env)->ReleaseStringUTFChars (env, jpath, path);
2182   if (r == -1) {
2183     throw_exception (env, guestfs_last_error (g));
2184     return ;
2185   }
2186 }
2187
2188 JNIEXPORT void JNICALL
2189 Java_com_redhat_et_libguestfs_GuestFS__1rmdir
2190   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2191 {
2192   guestfs_h *g = (guestfs_h *) (long) jg;
2193   int r;
2194   const char *path;
2195
2196   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2197   r = guestfs_rmdir (g, path);
2198   (*env)->ReleaseStringUTFChars (env, jpath, path);
2199   if (r == -1) {
2200     throw_exception (env, guestfs_last_error (g));
2201     return ;
2202   }
2203 }
2204
2205 JNIEXPORT void JNICALL
2206 Java_com_redhat_et_libguestfs_GuestFS__1rm_1rf
2207   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2208 {
2209   guestfs_h *g = (guestfs_h *) (long) jg;
2210   int r;
2211   const char *path;
2212
2213   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2214   r = guestfs_rm_rf (g, path);
2215   (*env)->ReleaseStringUTFChars (env, jpath, path);
2216   if (r == -1) {
2217     throw_exception (env, guestfs_last_error (g));
2218     return ;
2219   }
2220 }
2221
2222 JNIEXPORT void JNICALL
2223 Java_com_redhat_et_libguestfs_GuestFS__1mkdir
2224   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2225 {
2226   guestfs_h *g = (guestfs_h *) (long) jg;
2227   int r;
2228   const char *path;
2229
2230   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2231   r = guestfs_mkdir (g, path);
2232   (*env)->ReleaseStringUTFChars (env, jpath, path);
2233   if (r == -1) {
2234     throw_exception (env, guestfs_last_error (g));
2235     return ;
2236   }
2237 }
2238
2239 JNIEXPORT void JNICALL
2240 Java_com_redhat_et_libguestfs_GuestFS__1mkdir_1p
2241   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2242 {
2243   guestfs_h *g = (guestfs_h *) (long) jg;
2244   int r;
2245   const char *path;
2246
2247   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2248   r = guestfs_mkdir_p (g, path);
2249   (*env)->ReleaseStringUTFChars (env, jpath, path);
2250   if (r == -1) {
2251     throw_exception (env, guestfs_last_error (g));
2252     return ;
2253   }
2254 }
2255
2256 JNIEXPORT void JNICALL
2257 Java_com_redhat_et_libguestfs_GuestFS__1chmod
2258   (JNIEnv *env, jobject obj, jlong jg, jint jmode, jstring jpath)
2259 {
2260   guestfs_h *g = (guestfs_h *) (long) jg;
2261   int r;
2262   int mode;
2263   const char *path;
2264
2265   mode = jmode;
2266   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2267   r = guestfs_chmod (g, mode, path);
2268   (*env)->ReleaseStringUTFChars (env, jpath, path);
2269   if (r == -1) {
2270     throw_exception (env, guestfs_last_error (g));
2271     return ;
2272   }
2273 }
2274
2275 JNIEXPORT void JNICALL
2276 Java_com_redhat_et_libguestfs_GuestFS__1chown
2277   (JNIEnv *env, jobject obj, jlong jg, jint jowner, jint jgroup, jstring jpath)
2278 {
2279   guestfs_h *g = (guestfs_h *) (long) jg;
2280   int r;
2281   int owner;
2282   int group;
2283   const char *path;
2284
2285   owner = jowner;
2286   group = jgroup;
2287   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2288   r = guestfs_chown (g, owner, group, path);
2289   (*env)->ReleaseStringUTFChars (env, jpath, path);
2290   if (r == -1) {
2291     throw_exception (env, guestfs_last_error (g));
2292     return ;
2293   }
2294 }
2295
2296 JNIEXPORT jboolean JNICALL
2297 Java_com_redhat_et_libguestfs_GuestFS__1exists
2298   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2299 {
2300   guestfs_h *g = (guestfs_h *) (long) jg;
2301   int r;
2302   const char *path;
2303
2304   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2305   r = guestfs_exists (g, path);
2306   (*env)->ReleaseStringUTFChars (env, jpath, path);
2307   if (r == -1) {
2308     throw_exception (env, guestfs_last_error (g));
2309     return 0;
2310   }
2311   return (jboolean) r;
2312 }
2313
2314 JNIEXPORT jboolean JNICALL
2315 Java_com_redhat_et_libguestfs_GuestFS__1is_1file
2316   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2317 {
2318   guestfs_h *g = (guestfs_h *) (long) jg;
2319   int r;
2320   const char *path;
2321
2322   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2323   r = guestfs_is_file (g, path);
2324   (*env)->ReleaseStringUTFChars (env, jpath, path);
2325   if (r == -1) {
2326     throw_exception (env, guestfs_last_error (g));
2327     return 0;
2328   }
2329   return (jboolean) r;
2330 }
2331
2332 JNIEXPORT jboolean JNICALL
2333 Java_com_redhat_et_libguestfs_GuestFS__1is_1dir
2334   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2335 {
2336   guestfs_h *g = (guestfs_h *) (long) jg;
2337   int r;
2338   const char *path;
2339
2340   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2341   r = guestfs_is_dir (g, path);
2342   (*env)->ReleaseStringUTFChars (env, jpath, path);
2343   if (r == -1) {
2344     throw_exception (env, guestfs_last_error (g));
2345     return 0;
2346   }
2347   return (jboolean) r;
2348 }
2349
2350 JNIEXPORT void JNICALL
2351 Java_com_redhat_et_libguestfs_GuestFS__1pvcreate
2352   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2353 {
2354   guestfs_h *g = (guestfs_h *) (long) jg;
2355   int r;
2356   const char *device;
2357
2358   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2359   r = guestfs_pvcreate (g, device);
2360   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2361   if (r == -1) {
2362     throw_exception (env, guestfs_last_error (g));
2363     return ;
2364   }
2365 }
2366
2367 JNIEXPORT void JNICALL
2368 Java_com_redhat_et_libguestfs_GuestFS__1vgcreate
2369   (JNIEnv *env, jobject obj, jlong jg, jstring jvolgroup, jobjectArray jphysvols)
2370 {
2371   guestfs_h *g = (guestfs_h *) (long) jg;
2372   int r;
2373   const char *volgroup;
2374   int physvols_len;
2375   const char **physvols;
2376   int i;
2377
2378   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2379   physvols_len = (*env)->GetArrayLength (env, jphysvols);
2380   physvols = guestfs_safe_malloc (g, sizeof (char *) * (physvols_len+1));
2381   for (i = 0; i < physvols_len; ++i) {
2382     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2383     physvols[i] = (*env)->GetStringUTFChars (env, o, NULL);
2384   }
2385   physvols[physvols_len] = NULL;
2386   r = guestfs_vgcreate (g, volgroup, physvols);
2387   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2388   for (i = 0; i < physvols_len; ++i) {
2389     jobject o = (*env)->GetObjectArrayElement (env, jphysvols, i);
2390     (*env)->ReleaseStringUTFChars (env, o, physvols[i]);
2391   }
2392   free (physvols);
2393   if (r == -1) {
2394     throw_exception (env, guestfs_last_error (g));
2395     return ;
2396   }
2397 }
2398
2399 JNIEXPORT void JNICALL
2400 Java_com_redhat_et_libguestfs_GuestFS__1lvcreate
2401   (JNIEnv *env, jobject obj, jlong jg, jstring jlogvol, jstring jvolgroup, jint jmbytes)
2402 {
2403   guestfs_h *g = (guestfs_h *) (long) jg;
2404   int r;
2405   const char *logvol;
2406   const char *volgroup;
2407   int mbytes;
2408
2409   logvol = (*env)->GetStringUTFChars (env, jlogvol, NULL);
2410   volgroup = (*env)->GetStringUTFChars (env, jvolgroup, NULL);
2411   mbytes = jmbytes;
2412   r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
2413   (*env)->ReleaseStringUTFChars (env, jlogvol, logvol);
2414   (*env)->ReleaseStringUTFChars (env, jvolgroup, volgroup);
2415   if (r == -1) {
2416     throw_exception (env, guestfs_last_error (g));
2417     return ;
2418   }
2419 }
2420
2421 JNIEXPORT void JNICALL
2422 Java_com_redhat_et_libguestfs_GuestFS__1mkfs
2423   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
2424 {
2425   guestfs_h *g = (guestfs_h *) (long) jg;
2426   int r;
2427   const char *fstype;
2428   const char *device;
2429
2430   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
2431   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2432   r = guestfs_mkfs (g, fstype, device);
2433   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
2434   (*env)->ReleaseStringUTFChars (env, jdevice, device);
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__1sfdisk
2443   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jcyls, jint jheads, jint jsectors, jobjectArray jlines)
2444 {
2445   guestfs_h *g = (guestfs_h *) (long) jg;
2446   int r;
2447   const char *device;
2448   int cyls;
2449   int heads;
2450   int sectors;
2451   int lines_len;
2452   const char **lines;
2453   int i;
2454
2455   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2456   cyls = jcyls;
2457   heads = jheads;
2458   sectors = jsectors;
2459   lines_len = (*env)->GetArrayLength (env, jlines);
2460   lines = guestfs_safe_malloc (g, sizeof (char *) * (lines_len+1));
2461   for (i = 0; i < lines_len; ++i) {
2462     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2463     lines[i] = (*env)->GetStringUTFChars (env, o, NULL);
2464   }
2465   lines[lines_len] = NULL;
2466   r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
2467   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2468   for (i = 0; i < lines_len; ++i) {
2469     jobject o = (*env)->GetObjectArrayElement (env, jlines, i);
2470     (*env)->ReleaseStringUTFChars (env, o, lines[i]);
2471   }
2472   free (lines);
2473   if (r == -1) {
2474     throw_exception (env, guestfs_last_error (g));
2475     return ;
2476   }
2477 }
2478
2479 JNIEXPORT void JNICALL
2480 Java_com_redhat_et_libguestfs_GuestFS__1write_1file
2481   (JNIEnv *env, jobject obj, jlong jg, jstring jpath, jstring jcontent, jint jsize)
2482 {
2483   guestfs_h *g = (guestfs_h *) (long) jg;
2484   int r;
2485   const char *path;
2486   const char *content;
2487   int size;
2488
2489   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2490   content = (*env)->GetStringUTFChars (env, jcontent, NULL);
2491   size = jsize;
2492   r = guestfs_write_file (g, path, content, size);
2493   (*env)->ReleaseStringUTFChars (env, jpath, path);
2494   (*env)->ReleaseStringUTFChars (env, jcontent, content);
2495   if (r == -1) {
2496     throw_exception (env, guestfs_last_error (g));
2497     return ;
2498   }
2499 }
2500
2501 JNIEXPORT void JNICALL
2502 Java_com_redhat_et_libguestfs_GuestFS__1umount
2503   (JNIEnv *env, jobject obj, jlong jg, jstring jpathordevice)
2504 {
2505   guestfs_h *g = (guestfs_h *) (long) jg;
2506   int r;
2507   const char *pathordevice;
2508
2509   pathordevice = (*env)->GetStringUTFChars (env, jpathordevice, NULL);
2510   r = guestfs_umount (g, pathordevice);
2511   (*env)->ReleaseStringUTFChars (env, jpathordevice, pathordevice);
2512   if (r == -1) {
2513     throw_exception (env, guestfs_last_error (g));
2514     return ;
2515   }
2516 }
2517
2518 JNIEXPORT jobjectArray JNICALL
2519 Java_com_redhat_et_libguestfs_GuestFS__1mounts
2520   (JNIEnv *env, jobject obj, jlong jg)
2521 {
2522   guestfs_h *g = (guestfs_h *) (long) jg;
2523   jobjectArray jr;
2524   int r_len;
2525   jclass cl;
2526   jstring jstr;
2527   char **r;
2528   int i;
2529
2530   r = guestfs_mounts (g);
2531   if (r == NULL) {
2532     throw_exception (env, guestfs_last_error (g));
2533     return NULL;
2534   }
2535   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2536   cl = (*env)->FindClass (env, "java/lang/String");
2537   jstr = (*env)->NewStringUTF (env, "");
2538   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2539   for (i = 0; i < r_len; ++i) {
2540     jstr = (*env)->NewStringUTF (env, r[i]);
2541     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2542     free (r[i]);
2543   }
2544   free (r);
2545   return jr;
2546 }
2547
2548 JNIEXPORT void JNICALL
2549 Java_com_redhat_et_libguestfs_GuestFS__1umount_1all
2550   (JNIEnv *env, jobject obj, jlong jg)
2551 {
2552   guestfs_h *g = (guestfs_h *) (long) jg;
2553   int r;
2554
2555   r = guestfs_umount_all (g);
2556   if (r == -1) {
2557     throw_exception (env, guestfs_last_error (g));
2558     return ;
2559   }
2560 }
2561
2562 JNIEXPORT void JNICALL
2563 Java_com_redhat_et_libguestfs_GuestFS__1lvm_1remove_1all
2564   (JNIEnv *env, jobject obj, jlong jg)
2565 {
2566   guestfs_h *g = (guestfs_h *) (long) jg;
2567   int r;
2568
2569   r = guestfs_lvm_remove_all (g);
2570   if (r == -1) {
2571     throw_exception (env, guestfs_last_error (g));
2572     return ;
2573   }
2574 }
2575
2576 JNIEXPORT jstring JNICALL
2577 Java_com_redhat_et_libguestfs_GuestFS__1file
2578   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2579 {
2580   guestfs_h *g = (guestfs_h *) (long) jg;
2581   jstring jr;
2582   char *r;
2583   const char *path;
2584
2585   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2586   r = guestfs_file (g, path);
2587   (*env)->ReleaseStringUTFChars (env, jpath, path);
2588   if (r == NULL) {
2589     throw_exception (env, guestfs_last_error (g));
2590     return NULL;
2591   }
2592   jr = (*env)->NewStringUTF (env, r);
2593   free (r);
2594   return jr;
2595 }
2596
2597 JNIEXPORT jstring JNICALL
2598 Java_com_redhat_et_libguestfs_GuestFS__1command
2599   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2600 {
2601   guestfs_h *g = (guestfs_h *) (long) jg;
2602   jstring jr;
2603   char *r;
2604   int arguments_len;
2605   const char **arguments;
2606   int i;
2607
2608   arguments_len = (*env)->GetArrayLength (env, jarguments);
2609   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2610   for (i = 0; i < arguments_len; ++i) {
2611     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2612     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2613   }
2614   arguments[arguments_len] = NULL;
2615   r = guestfs_command (g, arguments);
2616   for (i = 0; i < arguments_len; ++i) {
2617     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2618     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2619   }
2620   free (arguments);
2621   if (r == NULL) {
2622     throw_exception (env, guestfs_last_error (g));
2623     return NULL;
2624   }
2625   jr = (*env)->NewStringUTF (env, r);
2626   free (r);
2627   return jr;
2628 }
2629
2630 JNIEXPORT jobjectArray JNICALL
2631 Java_com_redhat_et_libguestfs_GuestFS__1command_1lines
2632   (JNIEnv *env, jobject obj, jlong jg, jobjectArray jarguments)
2633 {
2634   guestfs_h *g = (guestfs_h *) (long) jg;
2635   jobjectArray jr;
2636   int r_len;
2637   jclass cl;
2638   jstring jstr;
2639   char **r;
2640   int arguments_len;
2641   const char **arguments;
2642   int i;
2643
2644   arguments_len = (*env)->GetArrayLength (env, jarguments);
2645   arguments = guestfs_safe_malloc (g, sizeof (char *) * (arguments_len+1));
2646   for (i = 0; i < arguments_len; ++i) {
2647     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2648     arguments[i] = (*env)->GetStringUTFChars (env, o, NULL);
2649   }
2650   arguments[arguments_len] = NULL;
2651   r = guestfs_command_lines (g, arguments);
2652   for (i = 0; i < arguments_len; ++i) {
2653     jobject o = (*env)->GetObjectArrayElement (env, jarguments, i);
2654     (*env)->ReleaseStringUTFChars (env, o, arguments[i]);
2655   }
2656   free (arguments);
2657   if (r == NULL) {
2658     throw_exception (env, guestfs_last_error (g));
2659     return NULL;
2660   }
2661   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
2662   cl = (*env)->FindClass (env, "java/lang/String");
2663   jstr = (*env)->NewStringUTF (env, "");
2664   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
2665   for (i = 0; i < r_len; ++i) {
2666     jstr = (*env)->NewStringUTF (env, r[i]);
2667     (*env)->SetObjectArrayElement (env, jr, i, jstr);
2668     free (r[i]);
2669   }
2670   free (r);
2671   return jr;
2672 }
2673
2674 JNIEXPORT jobject JNICALL
2675 Java_com_redhat_et_libguestfs_GuestFS__1stat
2676   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2677 {
2678   guestfs_h *g = (guestfs_h *) (long) jg;
2679   jobject jr;
2680   jclass cl;
2681   jfieldID fl;
2682   struct guestfs_stat *r;
2683   const char *path;
2684
2685   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2686   r = guestfs_stat (g, path);
2687   (*env)->ReleaseStringUTFChars (env, jpath, path);
2688   if (r == NULL) {
2689     throw_exception (env, guestfs_last_error (g));
2690     return NULL;
2691   }
2692   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2693   jr = (*env)->AllocObject (env, cl);
2694   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2695   (*env)->SetLongField (env, jr, fl, r->dev);
2696   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2697   (*env)->SetLongField (env, jr, fl, r->ino);
2698   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2699   (*env)->SetLongField (env, jr, fl, r->mode);
2700   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2701   (*env)->SetLongField (env, jr, fl, r->nlink);
2702   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2703   (*env)->SetLongField (env, jr, fl, r->uid);
2704   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2705   (*env)->SetLongField (env, jr, fl, r->gid);
2706   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2707   (*env)->SetLongField (env, jr, fl, r->rdev);
2708   fl = (*env)->GetFieldID (env, cl, "size", "J");
2709   (*env)->SetLongField (env, jr, fl, r->size);
2710   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2711   (*env)->SetLongField (env, jr, fl, r->blksize);
2712   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2713   (*env)->SetLongField (env, jr, fl, r->blocks);
2714   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2715   (*env)->SetLongField (env, jr, fl, r->atime);
2716   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2717   (*env)->SetLongField (env, jr, fl, r->mtime);
2718   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2719   (*env)->SetLongField (env, jr, fl, r->ctime);
2720   free (r);
2721   return jr;
2722 }
2723
2724 JNIEXPORT jobject JNICALL
2725 Java_com_redhat_et_libguestfs_GuestFS__1lstat
2726   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2727 {
2728   guestfs_h *g = (guestfs_h *) (long) jg;
2729   jobject jr;
2730   jclass cl;
2731   jfieldID fl;
2732   struct guestfs_stat *r;
2733   const char *path;
2734
2735   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2736   r = guestfs_lstat (g, path);
2737   (*env)->ReleaseStringUTFChars (env, jpath, path);
2738   if (r == NULL) {
2739     throw_exception (env, guestfs_last_error (g));
2740     return NULL;
2741   }
2742   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/Stat");
2743   jr = (*env)->AllocObject (env, cl);
2744   fl = (*env)->GetFieldID (env, cl, "dev", "J");
2745   (*env)->SetLongField (env, jr, fl, r->dev);
2746   fl = (*env)->GetFieldID (env, cl, "ino", "J");
2747   (*env)->SetLongField (env, jr, fl, r->ino);
2748   fl = (*env)->GetFieldID (env, cl, "mode", "J");
2749   (*env)->SetLongField (env, jr, fl, r->mode);
2750   fl = (*env)->GetFieldID (env, cl, "nlink", "J");
2751   (*env)->SetLongField (env, jr, fl, r->nlink);
2752   fl = (*env)->GetFieldID (env, cl, "uid", "J");
2753   (*env)->SetLongField (env, jr, fl, r->uid);
2754   fl = (*env)->GetFieldID (env, cl, "gid", "J");
2755   (*env)->SetLongField (env, jr, fl, r->gid);
2756   fl = (*env)->GetFieldID (env, cl, "rdev", "J");
2757   (*env)->SetLongField (env, jr, fl, r->rdev);
2758   fl = (*env)->GetFieldID (env, cl, "size", "J");
2759   (*env)->SetLongField (env, jr, fl, r->size);
2760   fl = (*env)->GetFieldID (env, cl, "blksize", "J");
2761   (*env)->SetLongField (env, jr, fl, r->blksize);
2762   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2763   (*env)->SetLongField (env, jr, fl, r->blocks);
2764   fl = (*env)->GetFieldID (env, cl, "atime", "J");
2765   (*env)->SetLongField (env, jr, fl, r->atime);
2766   fl = (*env)->GetFieldID (env, cl, "mtime", "J");
2767   (*env)->SetLongField (env, jr, fl, r->mtime);
2768   fl = (*env)->GetFieldID (env, cl, "ctime", "J");
2769   (*env)->SetLongField (env, jr, fl, r->ctime);
2770   free (r);
2771   return jr;
2772 }
2773
2774 JNIEXPORT jobject JNICALL
2775 Java_com_redhat_et_libguestfs_GuestFS__1statvfs
2776   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
2777 {
2778   guestfs_h *g = (guestfs_h *) (long) jg;
2779   jobject jr;
2780   jclass cl;
2781   jfieldID fl;
2782   struct guestfs_statvfs *r;
2783   const char *path;
2784
2785   path = (*env)->GetStringUTFChars (env, jpath, NULL);
2786   r = guestfs_statvfs (g, path);
2787   (*env)->ReleaseStringUTFChars (env, jpath, path);
2788   if (r == NULL) {
2789     throw_exception (env, guestfs_last_error (g));
2790     return NULL;
2791   }
2792   cl = (*env)->FindClass (env, "com/redhat/et/libguestfs/StatVFS");
2793   jr = (*env)->AllocObject (env, cl);
2794   fl = (*env)->GetFieldID (env, cl, "bsize", "J");
2795   (*env)->SetLongField (env, jr, fl, r->bsize);
2796   fl = (*env)->GetFieldID (env, cl, "frsize", "J");
2797   (*env)->SetLongField (env, jr, fl, r->frsize);
2798   fl = (*env)->GetFieldID (env, cl, "blocks", "J");
2799   (*env)->SetLongField (env, jr, fl, r->blocks);
2800   fl = (*env)->GetFieldID (env, cl, "bfree", "J");
2801   (*env)->SetLongField (env, jr, fl, r->bfree);
2802   fl = (*env)->GetFieldID (env, cl, "bavail", "J");
2803   (*env)->SetLongField (env, jr, fl, r->bavail);
2804   fl = (*env)->GetFieldID (env, cl, "files", "J");
2805   (*env)->SetLongField (env, jr, fl, r->files);
2806   fl = (*env)->GetFieldID (env, cl, "ffree", "J");
2807   (*env)->SetLongField (env, jr, fl, r->ffree);
2808   fl = (*env)->GetFieldID (env, cl, "favail", "J");
2809   (*env)->SetLongField (env, jr, fl, r->favail);
2810   fl = (*env)->GetFieldID (env, cl, "fsid", "J");
2811   (*env)->SetLongField (env, jr, fl, r->fsid);
2812   fl = (*env)->GetFieldID (env, cl, "flag", "J");
2813   (*env)->SetLongField (env, jr, fl, r->flag);
2814   fl = (*env)->GetFieldID (env, cl, "namemax", "J");
2815   (*env)->SetLongField (env, jr, fl, r->namemax);
2816   free (r);
2817   return jr;
2818 }
2819
2820 JNIEXPORT jobject JNICALL
2821 Java_com_redhat_et_libguestfs_GuestFS__1tune2fs_1l
2822   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2823 {
2824   guestfs_h *g = (guestfs_h *) (long) jg;
2825   char **r;
2826   const char *device;
2827
2828   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2829   r = guestfs_tune2fs_l (g, device);
2830   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2831   if (r == NULL) {
2832     throw_exception (env, guestfs_last_error (g));
2833     return NULL;
2834   }
2835   throw_exception (env, "tune2fs_l: internal error: please let us know how to make a Java HashMap from JNI bindings!");
2836   return NULL;
2837 }
2838
2839 JNIEXPORT void JNICALL
2840 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setro
2841   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2842 {
2843   guestfs_h *g = (guestfs_h *) (long) jg;
2844   int r;
2845   const char *device;
2846
2847   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2848   r = guestfs_blockdev_setro (g, device);
2849   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2850   if (r == -1) {
2851     throw_exception (env, guestfs_last_error (g));
2852     return ;
2853   }
2854 }
2855
2856 JNIEXPORT void JNICALL
2857 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setrw
2858   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2859 {
2860   guestfs_h *g = (guestfs_h *) (long) jg;
2861   int r;
2862   const char *device;
2863
2864   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2865   r = guestfs_blockdev_setrw (g, device);
2866   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2867   if (r == -1) {
2868     throw_exception (env, guestfs_last_error (g));
2869     return ;
2870   }
2871 }
2872
2873 JNIEXPORT jboolean JNICALL
2874 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getro
2875   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2876 {
2877   guestfs_h *g = (guestfs_h *) (long) jg;
2878   int r;
2879   const char *device;
2880
2881   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2882   r = guestfs_blockdev_getro (g, device);
2883   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2884   if (r == -1) {
2885     throw_exception (env, guestfs_last_error (g));
2886     return 0;
2887   }
2888   return (jboolean) r;
2889 }
2890
2891 JNIEXPORT jint JNICALL
2892 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getss
2893   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2894 {
2895   guestfs_h *g = (guestfs_h *) (long) jg;
2896   int r;
2897   const char *device;
2898
2899   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2900   r = guestfs_blockdev_getss (g, device);
2901   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2902   if (r == -1) {
2903     throw_exception (env, guestfs_last_error (g));
2904     return 0;
2905   }
2906   return (jint) r;
2907 }
2908
2909 JNIEXPORT jint JNICALL
2910 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getbsz
2911   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2912 {
2913   guestfs_h *g = (guestfs_h *) (long) jg;
2914   int r;
2915   const char *device;
2916
2917   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2918   r = guestfs_blockdev_getbsz (g, device);
2919   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2920   if (r == -1) {
2921     throw_exception (env, guestfs_last_error (g));
2922     return 0;
2923   }
2924   return (jint) r;
2925 }
2926
2927 JNIEXPORT void JNICALL
2928 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1setbsz
2929   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jint jblocksize)
2930 {
2931   guestfs_h *g = (guestfs_h *) (long) jg;
2932   int r;
2933   const char *device;
2934   int blocksize;
2935
2936   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2937   blocksize = jblocksize;
2938   r = guestfs_blockdev_setbsz (g, device, blocksize);
2939   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2940   if (r == -1) {
2941     throw_exception (env, guestfs_last_error (g));
2942     return ;
2943   }
2944 }
2945
2946 JNIEXPORT jlong JNICALL
2947 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsz
2948   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2949 {
2950   guestfs_h *g = (guestfs_h *) (long) jg;
2951   int64_t r;
2952   const char *device;
2953
2954   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2955   r = guestfs_blockdev_getsz (g, device);
2956   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2957   if (r == -1) {
2958     throw_exception (env, guestfs_last_error (g));
2959     return 0;
2960   }
2961   return (jlong) r;
2962 }
2963
2964 JNIEXPORT jlong JNICALL
2965 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1getsize64
2966   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2967 {
2968   guestfs_h *g = (guestfs_h *) (long) jg;
2969   int64_t r;
2970   const char *device;
2971
2972   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2973   r = guestfs_blockdev_getsize64 (g, device);
2974   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2975   if (r == -1) {
2976     throw_exception (env, guestfs_last_error (g));
2977     return 0;
2978   }
2979   return (jlong) r;
2980 }
2981
2982 JNIEXPORT void JNICALL
2983 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1flushbufs
2984   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
2985 {
2986   guestfs_h *g = (guestfs_h *) (long) jg;
2987   int r;
2988   const char *device;
2989
2990   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
2991   r = guestfs_blockdev_flushbufs (g, device);
2992   (*env)->ReleaseStringUTFChars (env, jdevice, device);
2993   if (r == -1) {
2994     throw_exception (env, guestfs_last_error (g));
2995     return ;
2996   }
2997 }
2998
2999 JNIEXPORT void JNICALL
3000 Java_com_redhat_et_libguestfs_GuestFS__1blockdev_1rereadpt
3001   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3002 {
3003   guestfs_h *g = (guestfs_h *) (long) jg;
3004   int r;
3005   const char *device;
3006
3007   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3008   r = guestfs_blockdev_rereadpt (g, device);
3009   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3010   if (r == -1) {
3011     throw_exception (env, guestfs_last_error (g));
3012     return ;
3013   }
3014 }
3015
3016 JNIEXPORT void JNICALL
3017 Java_com_redhat_et_libguestfs_GuestFS__1upload
3018   (JNIEnv *env, jobject obj, jlong jg, jstring jfilename, jstring jremotefilename)
3019 {
3020   guestfs_h *g = (guestfs_h *) (long) jg;
3021   int r;
3022   const char *filename;
3023   const char *remotefilename;
3024
3025   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3026   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3027   r = guestfs_upload (g, filename, remotefilename);
3028   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3029   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
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__1download
3038   (JNIEnv *env, jobject obj, jlong jg, jstring jremotefilename, jstring jfilename)
3039 {
3040   guestfs_h *g = (guestfs_h *) (long) jg;
3041   int r;
3042   const char *remotefilename;
3043   const char *filename;
3044
3045   remotefilename = (*env)->GetStringUTFChars (env, jremotefilename, NULL);
3046   filename = (*env)->GetStringUTFChars (env, jfilename, NULL);
3047   r = guestfs_download (g, remotefilename, filename);
3048   (*env)->ReleaseStringUTFChars (env, jremotefilename, remotefilename);
3049   (*env)->ReleaseStringUTFChars (env, jfilename, filename);
3050   if (r == -1) {
3051     throw_exception (env, guestfs_last_error (g));
3052     return ;
3053   }
3054 }
3055
3056 JNIEXPORT jstring JNICALL
3057 Java_com_redhat_et_libguestfs_GuestFS__1checksum
3058   (JNIEnv *env, jobject obj, jlong jg, jstring jcsumtype, jstring jpath)
3059 {
3060   guestfs_h *g = (guestfs_h *) (long) jg;
3061   jstring jr;
3062   char *r;
3063   const char *csumtype;
3064   const char *path;
3065
3066   csumtype = (*env)->GetStringUTFChars (env, jcsumtype, NULL);
3067   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3068   r = guestfs_checksum (g, csumtype, path);
3069   (*env)->ReleaseStringUTFChars (env, jcsumtype, csumtype);
3070   (*env)->ReleaseStringUTFChars (env, jpath, path);
3071   if (r == NULL) {
3072     throw_exception (env, guestfs_last_error (g));
3073     return NULL;
3074   }
3075   jr = (*env)->NewStringUTF (env, r);
3076   free (r);
3077   return jr;
3078 }
3079
3080 JNIEXPORT void JNICALL
3081 Java_com_redhat_et_libguestfs_GuestFS__1tar_1in
3082   (JNIEnv *env, jobject obj, jlong jg, jstring jtarfile, jstring jdirectory)
3083 {
3084   guestfs_h *g = (guestfs_h *) (long) jg;
3085   int r;
3086   const char *tarfile;
3087   const char *directory;
3088
3089   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3090   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3091   r = guestfs_tar_in (g, tarfile, directory);
3092   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
3093   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3094   if (r == -1) {
3095     throw_exception (env, guestfs_last_error (g));
3096     return ;
3097   }
3098 }
3099
3100 JNIEXPORT void JNICALL
3101 Java_com_redhat_et_libguestfs_GuestFS__1tar_1out
3102   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarfile)
3103 {
3104   guestfs_h *g = (guestfs_h *) (long) jg;
3105   int r;
3106   const char *directory;
3107   const char *tarfile;
3108
3109   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3110   tarfile = (*env)->GetStringUTFChars (env, jtarfile, NULL);
3111   r = guestfs_tar_out (g, directory, tarfile);
3112   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3113   (*env)->ReleaseStringUTFChars (env, jtarfile, tarfile);
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__1tgz_1in
3122   (JNIEnv *env, jobject obj, jlong jg, jstring jtarball, jstring jdirectory)
3123 {
3124   guestfs_h *g = (guestfs_h *) (long) jg;
3125   int r;
3126   const char *tarball;
3127   const char *directory;
3128
3129   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3130   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3131   r = guestfs_tgz_in (g, tarball, directory);
3132   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
3133   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
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_1out
3142   (JNIEnv *env, jobject obj, jlong jg, jstring jdirectory, jstring jtarball)
3143 {
3144   guestfs_h *g = (guestfs_h *) (long) jg;
3145   int r;
3146   const char *directory;
3147   const char *tarball;
3148
3149   directory = (*env)->GetStringUTFChars (env, jdirectory, NULL);
3150   tarball = (*env)->GetStringUTFChars (env, jtarball, NULL);
3151   r = guestfs_tgz_out (g, directory, tarball);
3152   (*env)->ReleaseStringUTFChars (env, jdirectory, directory);
3153   (*env)->ReleaseStringUTFChars (env, jtarball, tarball);
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__1mount_1ro
3162   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jmountpoint)
3163 {
3164   guestfs_h *g = (guestfs_h *) (long) jg;
3165   int r;
3166   const char *device;
3167   const char *mountpoint;
3168
3169   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3170   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3171   r = guestfs_mount_ro (g, device, mountpoint);
3172   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3173   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
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_1options
3182   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jdevice, jstring jmountpoint)
3183 {
3184   guestfs_h *g = (guestfs_h *) (long) jg;
3185   int r;
3186   const char *options;
3187   const char *device;
3188   const char *mountpoint;
3189
3190   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3191   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3192   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3193   r = guestfs_mount_options (g, options, device, mountpoint);
3194   (*env)->ReleaseStringUTFChars (env, joptions, options);
3195   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3196   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3197   if (r == -1) {
3198     throw_exception (env, guestfs_last_error (g));
3199     return ;
3200   }
3201 }
3202
3203 JNIEXPORT void JNICALL
3204 Java_com_redhat_et_libguestfs_GuestFS__1mount_1vfs
3205   (JNIEnv *env, jobject obj, jlong jg, jstring joptions, jstring jvfstype, jstring jdevice, jstring jmountpoint)
3206 {
3207   guestfs_h *g = (guestfs_h *) (long) jg;
3208   int r;
3209   const char *options;
3210   const char *vfstype;
3211   const char *device;
3212   const char *mountpoint;
3213
3214   options = (*env)->GetStringUTFChars (env, joptions, NULL);
3215   vfstype = (*env)->GetStringUTFChars (env, jvfstype, NULL);
3216   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3217   mountpoint = (*env)->GetStringUTFChars (env, jmountpoint, NULL);
3218   r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3219   (*env)->ReleaseStringUTFChars (env, joptions, options);
3220   (*env)->ReleaseStringUTFChars (env, jvfstype, vfstype);
3221   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3222   (*env)->ReleaseStringUTFChars (env, jmountpoint, mountpoint);
3223   if (r == -1) {
3224     throw_exception (env, guestfs_last_error (g));
3225     return ;
3226   }
3227 }
3228
3229 JNIEXPORT jstring JNICALL
3230 Java_com_redhat_et_libguestfs_GuestFS__1debug
3231   (JNIEnv *env, jobject obj, jlong jg, jstring jsubcmd, jobjectArray jextraargs)
3232 {
3233   guestfs_h *g = (guestfs_h *) (long) jg;
3234   jstring jr;
3235   char *r;
3236   const char *subcmd;
3237   int extraargs_len;
3238   const char **extraargs;
3239   int i;
3240
3241   subcmd = (*env)->GetStringUTFChars (env, jsubcmd, NULL);
3242   extraargs_len = (*env)->GetArrayLength (env, jextraargs);
3243   extraargs = guestfs_safe_malloc (g, sizeof (char *) * (extraargs_len+1));
3244   for (i = 0; i < extraargs_len; ++i) {
3245     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3246     extraargs[i] = (*env)->GetStringUTFChars (env, o, NULL);
3247   }
3248   extraargs[extraargs_len] = NULL;
3249   r = guestfs_debug (g, subcmd, extraargs);
3250   (*env)->ReleaseStringUTFChars (env, jsubcmd, subcmd);
3251   for (i = 0; i < extraargs_len; ++i) {
3252     jobject o = (*env)->GetObjectArrayElement (env, jextraargs, i);
3253     (*env)->ReleaseStringUTFChars (env, o, extraargs[i]);
3254   }
3255   free (extraargs);
3256   if (r == NULL) {
3257     throw_exception (env, guestfs_last_error (g));
3258     return NULL;
3259   }
3260   jr = (*env)->NewStringUTF (env, r);
3261   free (r);
3262   return jr;
3263 }
3264
3265 JNIEXPORT void JNICALL
3266 Java_com_redhat_et_libguestfs_GuestFS__1lvremove
3267   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3268 {
3269   guestfs_h *g = (guestfs_h *) (long) jg;
3270   int r;
3271   const char *device;
3272
3273   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3274   r = guestfs_lvremove (g, device);
3275   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3276   if (r == -1) {
3277     throw_exception (env, guestfs_last_error (g));
3278     return ;
3279   }
3280 }
3281
3282 JNIEXPORT void JNICALL
3283 Java_com_redhat_et_libguestfs_GuestFS__1vgremove
3284   (JNIEnv *env, jobject obj, jlong jg, jstring jvgname)
3285 {
3286   guestfs_h *g = (guestfs_h *) (long) jg;
3287   int r;
3288   const char *vgname;
3289
3290   vgname = (*env)->GetStringUTFChars (env, jvgname, NULL);
3291   r = guestfs_vgremove (g, vgname);
3292   (*env)->ReleaseStringUTFChars (env, jvgname, vgname);
3293   if (r == -1) {
3294     throw_exception (env, guestfs_last_error (g));
3295     return ;
3296   }
3297 }
3298
3299 JNIEXPORT void JNICALL
3300 Java_com_redhat_et_libguestfs_GuestFS__1pvremove
3301   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3302 {
3303   guestfs_h *g = (guestfs_h *) (long) jg;
3304   int r;
3305   const char *device;
3306
3307   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3308   r = guestfs_pvremove (g, device);
3309   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3310   if (r == -1) {
3311     throw_exception (env, guestfs_last_error (g));
3312     return ;
3313   }
3314 }
3315
3316 JNIEXPORT void JNICALL
3317 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2label
3318   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring jlabel)
3319 {
3320   guestfs_h *g = (guestfs_h *) (long) jg;
3321   int r;
3322   const char *device;
3323   const char *label;
3324
3325   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3326   label = (*env)->GetStringUTFChars (env, jlabel, NULL);
3327   r = guestfs_set_e2label (g, device, label);
3328   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3329   (*env)->ReleaseStringUTFChars (env, jlabel, label);
3330   if (r == -1) {
3331     throw_exception (env, guestfs_last_error (g));
3332     return ;
3333   }
3334 }
3335
3336 JNIEXPORT jstring JNICALL
3337 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2label
3338   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3339 {
3340   guestfs_h *g = (guestfs_h *) (long) jg;
3341   jstring jr;
3342   char *r;
3343   const char *device;
3344
3345   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3346   r = guestfs_get_e2label (g, device);
3347   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3348   if (r == NULL) {
3349     throw_exception (env, guestfs_last_error (g));
3350     return NULL;
3351   }
3352   jr = (*env)->NewStringUTF (env, r);
3353   free (r);
3354   return jr;
3355 }
3356
3357 JNIEXPORT void JNICALL
3358 Java_com_redhat_et_libguestfs_GuestFS__1set_1e2uuid
3359   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice, jstring juuid)
3360 {
3361   guestfs_h *g = (guestfs_h *) (long) jg;
3362   int r;
3363   const char *device;
3364   const char *uuid;
3365
3366   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3367   uuid = (*env)->GetStringUTFChars (env, juuid, NULL);
3368   r = guestfs_set_e2uuid (g, device, uuid);
3369   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3370   (*env)->ReleaseStringUTFChars (env, juuid, uuid);
3371   if (r == -1) {
3372     throw_exception (env, guestfs_last_error (g));
3373     return ;
3374   }
3375 }
3376
3377 JNIEXPORT jstring JNICALL
3378 Java_com_redhat_et_libguestfs_GuestFS__1get_1e2uuid
3379   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3380 {
3381   guestfs_h *g = (guestfs_h *) (long) jg;
3382   jstring jr;
3383   char *r;
3384   const char *device;
3385
3386   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3387   r = guestfs_get_e2uuid (g, device);
3388   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3389   if (r == NULL) {
3390     throw_exception (env, guestfs_last_error (g));
3391     return NULL;
3392   }
3393   jr = (*env)->NewStringUTF (env, r);
3394   free (r);
3395   return jr;
3396 }
3397
3398 JNIEXPORT jint JNICALL
3399 Java_com_redhat_et_libguestfs_GuestFS__1fsck
3400   (JNIEnv *env, jobject obj, jlong jg, jstring jfstype, jstring jdevice)
3401 {
3402   guestfs_h *g = (guestfs_h *) (long) jg;
3403   int r;
3404   const char *fstype;
3405   const char *device;
3406
3407   fstype = (*env)->GetStringUTFChars (env, jfstype, NULL);
3408   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3409   r = guestfs_fsck (g, fstype, device);
3410   (*env)->ReleaseStringUTFChars (env, jfstype, fstype);
3411   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3412   if (r == -1) {
3413     throw_exception (env, guestfs_last_error (g));
3414     return 0;
3415   }
3416   return (jint) r;
3417 }
3418
3419 JNIEXPORT void JNICALL
3420 Java_com_redhat_et_libguestfs_GuestFS__1zero
3421   (JNIEnv *env, jobject obj, jlong jg, jstring jdevice)
3422 {
3423   guestfs_h *g = (guestfs_h *) (long) jg;
3424   int r;
3425   const char *device;
3426
3427   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3428   r = guestfs_zero (g, device);
3429   (*env)->ReleaseStringUTFChars (env, jdevice, device);
3430   if (r == -1) {
3431     throw_exception (env, guestfs_last_error (g));
3432     return ;
3433   }
3434 }
3435
3436 JNIEXPORT void JNICALL
3437 Java_com_redhat_et_libguestfs_GuestFS__1grub_1install
3438   (JNIEnv *env, jobject obj, jlong jg, jstring jroot, jstring jdevice)
3439 {
3440   guestfs_h *g = (guestfs_h *) (long) jg;
3441   int r;
3442   const char *root;
3443   const char *device;
3444
3445   root = (*env)->GetStringUTFChars (env, jroot, NULL);
3446   device = (*env)->GetStringUTFChars (env, jdevice, NULL);
3447   r = guestfs_grub_install (g, root, device);
3448   (*env)->ReleaseStringUTFChars (env, jroot, root);
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__1cp
3458   (JNIEnv *env, jobject obj, jlong jg, jstring jsrc, jstring jdest)
3459 {
3460   guestfs_h *g = (guestfs_h *) (long) jg;
3461   int r;
3462   const char *src;
3463   const char *dest;
3464
3465   src = (*env)->GetStringUTFChars (env, jsrc, NULL);
3466   dest = (*env)->GetStringUTFChars (env, jdest, NULL);
3467   r = guestfs_cp (g, src, dest);
3468   (*env)->ReleaseStringUTFChars (env, jsrc, src);
3469   (*env)->ReleaseStringUTFChars (env, jdest, dest);
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_1a
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_a (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__1mv
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_mv (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__1drop_1caches
3518   (JNIEnv *env, jobject obj, jlong jg, jint jwhattodrop)
3519 {
3520   guestfs_h *g = (guestfs_h *) (long) jg;
3521   int r;
3522   int whattodrop;
3523
3524   whattodrop = jwhattodrop;
3525   r = guestfs_drop_caches (g, whattodrop);
3526   if (r == -1) {
3527     throw_exception (env, guestfs_last_error (g));
3528     return ;
3529   }
3530 }
3531
3532 JNIEXPORT jstring JNICALL
3533 Java_com_redhat_et_libguestfs_GuestFS__1dmesg
3534   (JNIEnv *env, jobject obj, jlong jg)
3535 {
3536   guestfs_h *g = (guestfs_h *) (long) jg;
3537   jstring jr;
3538   char *r;
3539
3540   r = guestfs_dmesg (g);
3541   if (r == NULL) {
3542     throw_exception (env, guestfs_last_error (g));
3543     return NULL;
3544   }
3545   jr = (*env)->NewStringUTF (env, r);
3546   free (r);
3547   return jr;
3548 }
3549
3550 JNIEXPORT void JNICALL
3551 Java_com_redhat_et_libguestfs_GuestFS__1ping_1daemon
3552   (JNIEnv *env, jobject obj, jlong jg)
3553 {
3554   guestfs_h *g = (guestfs_h *) (long) jg;
3555   int r;
3556
3557   r = guestfs_ping_daemon (g);
3558   if (r == -1) {
3559     throw_exception (env, guestfs_last_error (g));
3560     return ;
3561   }
3562 }
3563
3564 JNIEXPORT jboolean JNICALL
3565 Java_com_redhat_et_libguestfs_GuestFS__1equal
3566   (JNIEnv *env, jobject obj, jlong jg, jstring jfile1, jstring jfile2)
3567 {
3568   guestfs_h *g = (guestfs_h *) (long) jg;
3569   int r;
3570   const char *file1;
3571   const char *file2;
3572
3573   file1 = (*env)->GetStringUTFChars (env, jfile1, NULL);
3574   file2 = (*env)->GetStringUTFChars (env, jfile2, NULL);
3575   r = guestfs_equal (g, file1, file2);
3576   (*env)->ReleaseStringUTFChars (env, jfile1, file1);
3577   (*env)->ReleaseStringUTFChars (env, jfile2, file2);
3578   if (r == -1) {
3579     throw_exception (env, guestfs_last_error (g));
3580     return 0;
3581   }
3582   return (jboolean) r;
3583 }
3584
3585 JNIEXPORT jobjectArray JNICALL
3586 Java_com_redhat_et_libguestfs_GuestFS__1strings
3587   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3588 {
3589   guestfs_h *g = (guestfs_h *) (long) jg;
3590   jobjectArray jr;
3591   int r_len;
3592   jclass cl;
3593   jstring jstr;
3594   char **r;
3595   const char *path;
3596   int i;
3597
3598   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3599   r = guestfs_strings (g, path);
3600   (*env)->ReleaseStringUTFChars (env, jpath, path);
3601   if (r == NULL) {
3602     throw_exception (env, guestfs_last_error (g));
3603     return NULL;
3604   }
3605   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3606   cl = (*env)->FindClass (env, "java/lang/String");
3607   jstr = (*env)->NewStringUTF (env, "");
3608   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3609   for (i = 0; i < r_len; ++i) {
3610     jstr = (*env)->NewStringUTF (env, r[i]);
3611     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3612     free (r[i]);
3613   }
3614   free (r);
3615   return jr;
3616 }
3617
3618 JNIEXPORT jobjectArray JNICALL
3619 Java_com_redhat_et_libguestfs_GuestFS__1strings_1e
3620   (JNIEnv *env, jobject obj, jlong jg, jstring jencoding, jstring jpath)
3621 {
3622   guestfs_h *g = (guestfs_h *) (long) jg;
3623   jobjectArray jr;
3624   int r_len;
3625   jclass cl;
3626   jstring jstr;
3627   char **r;
3628   const char *encoding;
3629   const char *path;
3630   int i;
3631
3632   encoding = (*env)->GetStringUTFChars (env, jencoding, NULL);
3633   path = (*env)->GetStringUTFChars (env, jpath, NULL);
3634   r = guestfs_strings_e (g, encoding, path);
3635   (*env)->ReleaseStringUTFChars (env, jencoding, encoding);
3636   (*env)->ReleaseStringUTFChars (env, jpath, path);
3637   if (r == NULL) {
3638     throw_exception (env, guestfs_last_error (g));
3639     return NULL;
3640   }
3641   for (r_len = 0; r[r_len] != NULL; ++r_len) ;
3642   cl = (*env)->FindClass (env, "java/lang/String");
3643   jstr = (*env)->NewStringUTF (env, "");
3644   jr = (*env)->NewObjectArray (env, r_len, cl, jstr);
3645   for (i = 0; i < r_len; ++i) {
3646     jstr = (*env)->NewStringUTF (env, r[i]);
3647     (*env)->SetObjectArrayElement (env, jr, i, jstr);
3648     free (r[i]);
3649   }
3650   free (r);
3651   return jr;
3652 }
3653
3654 JNIEXPORT jstring JNICALL
3655 Java_com_redhat_et_libguestfs_GuestFS__1hexdump
3656   (JNIEnv *env, jobject obj, jlong jg, jstring jpath)
3657 {
3658   guestfs_h *g = (guestfs_h *) (long) jg;
3659   jstring jr;
3660   char *r;
3661   const char *path;
3662