perl/Guestfs.xs

   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 "EXTERN.h"
  23 #include "perl.h"
  24 #include "XSUB.h"
  25
  26 #include <guestfs.h>
  27
  28 #ifndef PRId64
  29 #define PRId64 "lld"
  30 #endif
  31
  32 static SV *
  33 my_newSVll(long long val) {
  34 #ifdef USE_64_BIT_ALL
  35   return newSViv(val);
  36 #else
  37   char buf[100];
  38   int len;
  39   len = snprintf(buf, 100, "%" PRId64, val);
  40   return newSVpv(buf, len);
  41 #endif
  42 }
  43
  44 #ifndef PRIu64
  45 #define PRIu64 "llu"
  46 #endif
  47
  48 static SV *
  49 my_newSVull(unsigned long long val) {
  50 #ifdef USE_64_BIT_ALL
  51   return newSVuv(val);
  52 #else
  53   char buf[100];
  54   int len;
  55   len = snprintf(buf, 100, "%" PRIu64, val);
  56   return newSVpv(buf, len);
  57 #endif
  58 }
  59
  60 /* http://www.perlmonks.org/?node_id=680842 */
  61 static char **
  62 XS_unpack_charPtrPtr (SV *arg) {
  63   char **ret;
  64   AV *av;
  65   I32 i;
  66
  67   if (!arg || !SvOK (arg) || !SvROK (arg) || SvTYPE (SvRV (arg)) != SVt_PVAV) {
  68     croak ("array reference expected");
  69   }
  70
  71   av = (AV *)SvRV (arg);
  72   ret = (char **)malloc (av_len (av) + 1 + 1);
  73
  74   for (i = 0; i <= av_len (av); i++) {
  75     SV **elem = av_fetch (av, i, 0);
  76
  77     if (!elem || !*elem)
  78       croak ("missing element in list");
  79
  80     ret[i] = SvPV_nolen (*elem);
  81   }
  82
  83   ret[i] = NULL;
  84
  85   return ret;
  86 }
  87
  88 MODULE = Sys::Guestfs  PACKAGE = Sys::Guestfs
  89
  90 guestfs_h *
  91 _create ()
  92    CODE:
  93       RETVAL = guestfs_create ();
  94       if (!RETVAL)
  95         croak ("could not create guestfs handle");
  96       guestfs_set_error_handler (RETVAL, NULL, NULL);
  97  OUTPUT:
  98       RETVAL
  99
 100 void
 101 DESTROY (g)
 102       guestfs_h *g;
 103  PPCODE:
 104       guestfs_close (g);
 105
 106 void
 107 launch (g)
 108       guestfs_h *g;
 109 PREINIT:
 110       int r;
 111  PPCODE:
 112       r = guestfs_launch (g);
 113       if (r == -1)
 114         croak ("launch: %s", guestfs_last_error (g));
 115
 116 void
 117 wait_ready (g)
 118       guestfs_h *g;
 119 PREINIT:
 120       int r;
 121  PPCODE:
 122       r = guestfs_wait_ready (g);
 123       if (r == -1)
 124         croak ("wait_ready: %s", guestfs_last_error (g));
 125
 126 void
 127 kill_subprocess (g)
 128       guestfs_h *g;
 129 PREINIT:
 130       int r;
 131  PPCODE:
 132       r = guestfs_kill_subprocess (g);
 133       if (r == -1)
 134         croak ("kill_subprocess: %s", guestfs_last_error (g));
 135
 136 void
 137 add_drive (g, filename)
 138       guestfs_h *g;
 139       char *filename;
 140 PREINIT:
 141       int r;
 142  PPCODE:
 143       r = guestfs_add_drive (g, filename);
 144       if (r == -1)
 145         croak ("add_drive: %s", guestfs_last_error (g));
 146
 147 void
 148 add_cdrom (g, filename)
 149       guestfs_h *g;
 150       char *filename;
 151 PREINIT:
 152       int r;
 153  PPCODE:
 154       r = guestfs_add_cdrom (g, filename);
 155       if (r == -1)
 156         croak ("add_cdrom: %s", guestfs_last_error (g));
 157
 158 void
 159 config (g, qemuparam, qemuvalue)
 160       guestfs_h *g;
 161       char *qemuparam;
 162       char *qemuvalue;
 163 PREINIT:
 164       int r;
 165  PPCODE:
 166       r = guestfs_config (g, qemuparam, qemuvalue);
 167       if (r == -1)
 168         croak ("config: %s", guestfs_last_error (g));
 169
 170 void
 171 set_path (g, path)
 172       guestfs_h *g;
 173       char *path;
 174 PREINIT:
 175       int r;
 176  PPCODE:
 177       r = guestfs_set_path (g, path);
 178       if (r == -1)
 179         croak ("set_path: %s", guestfs_last_error (g));
 180
 181 SV *
 182 get_path (g)
 183       guestfs_h *g;
 184 PREINIT:
 185       const char *path;
 186    CODE:
 187       path = guestfs_get_path (g);
 188       if (path == NULL)
 189         croak ("get_path: %s", guestfs_last_error (g));
 190       RETVAL = newSVpv (path, 0);
 191  OUTPUT:
 192       RETVAL
 193
 194 void
 195 set_autosync (g, autosync)
 196       guestfs_h *g;
 197       int autosync;
 198 PREINIT:
 199       int r;
 200  PPCODE:
 201       r = guestfs_set_autosync (g, autosync);
 202       if (r == -1)
 203         croak ("set_autosync: %s", guestfs_last_error (g));
 204
 205 SV *
 206 get_autosync (g)
 207       guestfs_h *g;
 208 PREINIT:
 209       int autosync;
 210    CODE:
 211       autosync = guestfs_get_autosync (g);
 212       if (autosync == -1)
 213         croak ("get_autosync: %s", guestfs_last_error (g));
 214       RETVAL = newSViv (autosync);
 215  OUTPUT:
 216       RETVAL
 217
 218 void
 219 set_verbose (g, verbose)
 220       guestfs_h *g;
 221       int verbose;
 222 PREINIT:
 223       int r;
 224  PPCODE:
 225       r = guestfs_set_verbose (g, verbose);
 226       if (r == -1)
 227         croak ("set_verbose: %s", guestfs_last_error (g));
 228
 229 SV *
 230 get_verbose (g)
 231       guestfs_h *g;
 232 PREINIT:
 233       int verbose;
 234    CODE:
 235       verbose = guestfs_get_verbose (g);
 236       if (verbose == -1)
 237         croak ("get_verbose: %s", guestfs_last_error (g));
 238       RETVAL = newSViv (verbose);
 239  OUTPUT:
 240       RETVAL
 241
 242 SV *
 243 is_ready (g)
 244       guestfs_h *g;
 245 PREINIT:
 246       int ready;
 247    CODE:
 248       ready = guestfs_is_ready (g);
 249       if (ready == -1)
 250         croak ("is_ready: %s", guestfs_last_error (g));
 251       RETVAL = newSViv (ready);
 252  OUTPUT:
 253       RETVAL
 254
 255 SV *
 256 is_config (g)
 257       guestfs_h *g;
 258 PREINIT:
 259       int config;
 260    CODE:
 261       config = guestfs_is_config (g);
 262       if (config == -1)
 263         croak ("is_config: %s", guestfs_last_error (g));
 264       RETVAL = newSViv (config);
 265  OUTPUT:
 266       RETVAL
 267
 268 SV *
 269 is_launching (g)
 270       guestfs_h *g;
 271 PREINIT:
 272       int launching;
 273    CODE:
 274       launching = guestfs_is_launching (g);
 275       if (launching == -1)
 276         croak ("is_launching: %s", guestfs_last_error (g));
 277       RETVAL = newSViv (launching);
 278  OUTPUT:
 279       RETVAL
 280
 281 SV *
 282 is_busy (g)
 283       guestfs_h *g;
 284 PREINIT:
 285       int busy;
 286    CODE:
 287       busy = guestfs_is_busy (g);
 288       if (busy == -1)
 289         croak ("is_busy: %s", guestfs_last_error (g));
 290       RETVAL = newSViv (busy);
 291  OUTPUT:
 292       RETVAL
 293
 294 SV *
 295 get_state (g)
 296       guestfs_h *g;
 297 PREINIT:
 298       int state;
 299    CODE:
 300       state = guestfs_get_state (g);
 301       if (state == -1)
 302         croak ("get_state: %s", guestfs_last_error (g));
 303       RETVAL = newSViv (state);
 304  OUTPUT:
 305       RETVAL
 306
 307 void
 308 set_busy (g)
 309       guestfs_h *g;
 310 PREINIT:
 311       int r;
 312  PPCODE:
 313       r = guestfs_set_busy (g);
 314       if (r == -1)
 315         croak ("set_busy: %s", guestfs_last_error (g));
 316
 317 void
 318 set_ready (g)
 319       guestfs_h *g;
 320 PREINIT:
 321       int r;
 322  PPCODE:
 323       r = guestfs_set_ready (g);
 324       if (r == -1)
 325         croak ("set_ready: %s", guestfs_last_error (g));
 326
 327 void
 328 mount (g, device, mountpoint)
 329       guestfs_h *g;
 330       char *device;
 331       char *mountpoint;
 332 PREINIT:
 333       int r;
 334  PPCODE:
 335       r = guestfs_mount (g, device, mountpoint);
 336       if (r == -1)
 337         croak ("mount: %s", guestfs_last_error (g));
 338
 339 void
 340 sync (g)
 341       guestfs_h *g;
 342 PREINIT:
 343       int r;
 344  PPCODE:
 345       r = guestfs_sync (g);
 346       if (r == -1)
 347         croak ("sync: %s", guestfs_last_error (g));
 348
 349 void
 350 touch (g, path)
 351       guestfs_h *g;
 352       char *path;
 353 PREINIT:
 354       int r;
 355  PPCODE:
 356       r = guestfs_touch (g, path);
 357       if (r == -1)
 358         croak ("touch: %s", guestfs_last_error (g));
 359
 360 SV *
 361 cat (g, path)
 362       guestfs_h *g;
 363       char *path;
 364 PREINIT:
 365       char *content;
 366    CODE:
 367       content = guestfs_cat (g, path);
 368       if (content == NULL)
 369         croak ("cat: %s", guestfs_last_error (g));
 370       RETVAL = newSVpv (content, 0);
 371       free (content);
 372  OUTPUT:
 373       RETVAL
 374
 375 SV *
 376 ll (g, directory)
 377       guestfs_h *g;
 378       char *directory;
 379 PREINIT:
 380       char *listing;
 381    CODE:
 382       listing = guestfs_ll (g, directory);
 383       if (listing == NULL)
 384         croak ("ll: %s", guestfs_last_error (g));
 385       RETVAL = newSVpv (listing, 0);
 386       free (listing);
 387  OUTPUT:
 388       RETVAL
 389
 390 void
 391 ls (g, directory)
 392       guestfs_h *g;
 393       char *directory;
 394 PREINIT:
 395       char **listing;
 396       int i, n;
 397  PPCODE:
 398       listing = guestfs_ls (g, directory);
 399       if (listing == NULL)
 400         croak ("ls: %s", guestfs_last_error (g));
 401       for (n = 0; listing[n] != NULL; ++n) /**/;
 402       EXTEND (SP, n);
 403       for (i = 0; i < n; ++i) {
 404         PUSHs (sv_2mortal (newSVpv (listing[i], 0)));
 405         free (listing[i]);
 406       }
 407       free (listing);
 408
 409 void
 410 list_devices (g)
 411       guestfs_h *g;
 412 PREINIT:
 413       char **devices;
 414       int i, n;
 415  PPCODE:
 416       devices = guestfs_list_devices (g);
 417       if (devices == NULL)
 418         croak ("list_devices: %s", guestfs_last_error (g));
 419       for (n = 0; devices[n] != NULL; ++n) /**/;
 420       EXTEND (SP, n);
 421       for (i = 0; i < n; ++i) {
 422         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
 423         free (devices[i]);
 424       }
 425       free (devices);
 426
 427 void
 428 list_partitions (g)
 429       guestfs_h *g;
 430 PREINIT:
 431       char **partitions;
 432       int i, n;
 433  PPCODE:
 434       partitions = guestfs_list_partitions (g);
 435       if (partitions == NULL)
 436         croak ("list_partitions: %s", guestfs_last_error (g));
 437       for (n = 0; partitions[n] != NULL; ++n) /**/;
 438       EXTEND (SP, n);
 439       for (i = 0; i < n; ++i) {
 440         PUSHs (sv_2mortal (newSVpv (partitions[i], 0)));
 441         free (partitions[i]);
 442       }
 443       free (partitions);
 444
 445 void
 446 pvs (g)
 447       guestfs_h *g;
 448 PREINIT:
 449       char **physvols;
 450       int i, n;
 451  PPCODE:
 452       physvols = guestfs_pvs (g);
 453       if (physvols == NULL)
 454         croak ("pvs: %s", guestfs_last_error (g));
 455       for (n = 0; physvols[n] != NULL; ++n) /**/;
 456       EXTEND (SP, n);
 457       for (i = 0; i < n; ++i) {
 458         PUSHs (sv_2mortal (newSVpv (physvols[i], 0)));
 459         free (physvols[i]);
 460       }
 461       free (physvols);
 462
 463 void
 464 vgs (g)
 465       guestfs_h *g;
 466 PREINIT:
 467       char **volgroups;
 468       int i, n;
 469  PPCODE:
 470       volgroups = guestfs_vgs (g);
 471       if (volgroups == NULL)
 472         croak ("vgs: %s", guestfs_last_error (g));
 473       for (n = 0; volgroups[n] != NULL; ++n) /**/;
 474       EXTEND (SP, n);
 475       for (i = 0; i < n; ++i) {
 476         PUSHs (sv_2mortal (newSVpv (volgroups[i], 0)));
 477         free (volgroups[i]);
 478       }
 479       free (volgroups);
 480
 481 void
 482 lvs (g)
 483       guestfs_h *g;
 484 PREINIT:
 485       char **logvols;
 486       int i, n;
 487  PPCODE:
 488       logvols = guestfs_lvs (g);
 489       if (logvols == NULL)
 490         croak ("lvs: %s", guestfs_last_error (g));
 491       for (n = 0; logvols[n] != NULL; ++n) /**/;
 492       EXTEND (SP, n);
 493       for (i = 0; i < n; ++i) {
 494         PUSHs (sv_2mortal (newSVpv (logvols[i], 0)));
 495         free (logvols[i]);
 496       }
 497       free (logvols);
 498
 499 void
 500 pvs_full (g)
 501       guestfs_h *g;
 502 PREINIT:
 503       struct guestfs_lvm_pv_list *physvols;
 504       int i;
 505       HV *hv;
 506  PPCODE:
 507       physvols = guestfs_pvs_full (g);
 508       if (physvols == NULL)
 509         croak ("pvs_full: %s", guestfs_last_error (g));
 510       EXTEND (SP, physvols->len);
 511       for (i = 0; i < physvols->len; ++i) {
 512         hv = newHV ();
 513         (void) hv_store (hv, "pv_name", 7, newSVpv (physvols->val[i].pv_name, 0), 0);
 514         (void) hv_store (hv, "pv_uuid", 7, newSVpv (physvols->val[i].pv_uuid, 32), 0);
 515         (void) hv_store (hv, "pv_fmt", 6, newSVpv (physvols->val[i].pv_fmt, 0), 0);
 516         (void) hv_store (hv, "pv_size", 7, my_newSVull (physvols->val[i].pv_size), 0);
 517         (void) hv_store (hv, "dev_size", 8, my_newSVull (physvols->val[i].dev_size), 0);
 518         (void) hv_store (hv, "pv_free", 7, my_newSVull (physvols->val[i].pv_free), 0);
 519         (void) hv_store (hv, "pv_used", 7, my_newSVull (physvols->val[i].pv_used), 0);
 520         (void) hv_store (hv, "pv_attr", 7, newSVpv (physvols->val[i].pv_attr, 0), 0);
 521         (void) hv_store (hv, "pv_pe_count", 11, my_newSVll (physvols->val[i].pv_pe_count), 0);
 522         (void) hv_store (hv, "pv_pe_alloc_count", 17, my_newSVll (physvols->val[i].pv_pe_alloc_count), 0);
 523         (void) hv_store (hv, "pv_tags", 7, newSVpv (physvols->val[i].pv_tags, 0), 0);
 524         (void) hv_store (hv, "pe_start", 8, my_newSVull (physvols->val[i].pe_start), 0);
 525         (void) hv_store (hv, "pv_mda_count", 12, my_newSVll (physvols->val[i].pv_mda_count), 0);
 526         (void) hv_store (hv, "pv_mda_free", 11, my_newSVull (physvols->val[i].pv_mda_free), 0);
 527         PUSHs (sv_2mortal ((SV *) hv));
 528       }
 529       guestfs_free_lvm_pv_list (physvols);
 530
 531 void
 532 vgs_full (g)
 533       guestfs_h *g;
 534 PREINIT:
 535       struct guestfs_lvm_vg_list *volgroups;
 536       int i;
 537       HV *hv;
 538  PPCODE:
 539       volgroups = guestfs_vgs_full (g);
 540       if (volgroups == NULL)
 541         croak ("vgs_full: %s", guestfs_last_error (g));
 542       EXTEND (SP, volgroups->len);
 543       for (i = 0; i < volgroups->len; ++i) {
 544         hv = newHV ();
 545         (void) hv_store (hv, "vg_name", 7, newSVpv (volgroups->val[i].vg_name, 0), 0);
 546         (void) hv_store (hv, "vg_uuid", 7, newSVpv (volgroups->val[i].vg_uuid, 32), 0);
 547         (void) hv_store (hv, "vg_fmt", 6, newSVpv (volgroups->val[i].vg_fmt, 0), 0);
 548         (void) hv_store (hv, "vg_attr", 7, newSVpv (volgroups->val[i].vg_attr, 0), 0);
 549         (void) hv_store (hv, "vg_size", 7, my_newSVull (volgroups->val[i].vg_size), 0);
 550         (void) hv_store (hv, "vg_free", 7, my_newSVull (volgroups->val[i].vg_free), 0);
 551         (void) hv_store (hv, "vg_sysid", 8, newSVpv (volgroups->val[i].vg_sysid, 0), 0);
 552         (void) hv_store (hv, "vg_extent_size", 14, my_newSVull (volgroups->val[i].vg_extent_size), 0);
 553         (void) hv_store (hv, "vg_extent_count", 15, my_newSVll (volgroups->val[i].vg_extent_count), 0);
 554         (void) hv_store (hv, "vg_free_count", 13, my_newSVll (volgroups->val[i].vg_free_count), 0);
 555         (void) hv_store (hv, "max_lv", 6, my_newSVll (volgroups->val[i].max_lv), 0);
 556         (void) hv_store (hv, "max_pv", 6, my_newSVll (volgroups->val[i].max_pv), 0);
 557         (void) hv_store (hv, "pv_count", 8, my_newSVll (volgroups->val[i].pv_count), 0);
 558         (void) hv_store (hv, "lv_count", 8, my_newSVll (volgroups->val[i].lv_count), 0);
 559         (void) hv_store (hv, "snap_count", 10, my_newSVll (volgroups->val[i].snap_count), 0);
 560         (void) hv_store (hv, "vg_seqno", 8, my_newSVll (volgroups->val[i].vg_seqno), 0);
 561         (void) hv_store (hv, "vg_tags", 7, newSVpv (volgroups->val[i].vg_tags, 0), 0);
 562         (void) hv_store (hv, "vg_mda_count", 12, my_newSVll (volgroups->val[i].vg_mda_count), 0);
 563         (void) hv_store (hv, "vg_mda_free", 11, my_newSVull (volgroups->val[i].vg_mda_free), 0);
 564         PUSHs (sv_2mortal ((SV *) hv));
 565       }
 566       guestfs_free_lvm_vg_list (volgroups);
 567
 568 void
 569 lvs_full (g)
 570       guestfs_h *g;
 571 PREINIT:
 572       struct guestfs_lvm_lv_list *logvols;
 573       int i;
 574       HV *hv;
 575  PPCODE:
 576       logvols = guestfs_lvs_full (g);
 577       if (logvols == NULL)
 578         croak ("lvs_full: %s", guestfs_last_error (g));
 579       EXTEND (SP, logvols->len);
 580       for (i = 0; i < logvols->len; ++i) {
 581         hv = newHV ();
 582         (void) hv_store (hv, "lv_name", 7, newSVpv (logvols->val[i].lv_name, 0), 0);
 583         (void) hv_store (hv, "lv_uuid", 7, newSVpv (logvols->val[i].lv_uuid, 32), 0);
 584         (void) hv_store (hv, "lv_attr", 7, newSVpv (logvols->val[i].lv_attr, 0), 0);
 585         (void) hv_store (hv, "lv_major", 8, my_newSVll (logvols->val[i].lv_major), 0);
 586         (void) hv_store (hv, "lv_minor", 8, my_newSVll (logvols->val[i].lv_minor), 0);
 587         (void) hv_store (hv, "lv_kernel_major", 15, my_newSVll (logvols->val[i].lv_kernel_major), 0);
 588         (void) hv_store (hv, "lv_kernel_minor", 15, my_newSVll (logvols->val[i].lv_kernel_minor), 0);
 589         (void) hv_store (hv, "lv_size", 7, my_newSVull (logvols->val[i].lv_size), 0);
 590         (void) hv_store (hv, "seg_count", 9, my_newSVll (logvols->val[i].seg_count), 0);
 591         (void) hv_store (hv, "origin", 6, newSVpv (logvols->val[i].origin, 0), 0);
 592         (void) hv_store (hv, "snap_percent", 12, newSVnv (logvols->val[i].snap_percent), 0);
 593         (void) hv_store (hv, "copy_percent", 12, newSVnv (logvols->val[i].copy_percent), 0);
 594         (void) hv_store (hv, "move_pv", 7, newSVpv (logvols->val[i].move_pv, 0), 0);
 595         (void) hv_store (hv, "lv_tags", 7, newSVpv (logvols->val[i].lv_tags, 0), 0);
 596         (void) hv_store (hv, "mirror_log", 10, newSVpv (logvols->val[i].mirror_log, 0), 0);
 597         (void) hv_store (hv, "modules", 7, newSVpv (logvols->val[i].modules, 0), 0);
 598         PUSHs (sv_2mortal ((SV *) hv));
 599       }
 600       guestfs_free_lvm_lv_list (logvols);
 601
 602 void
 603 read_lines (g, path)
 604       guestfs_h *g;
 605       char *path;
 606 PREINIT:
 607       char **lines;
 608       int i, n;
 609  PPCODE:
 610       lines = guestfs_read_lines (g, path);
 611       if (lines == NULL)
 612         croak ("read_lines: %s", guestfs_last_error (g));
 613       for (n = 0; lines[n] != NULL; ++n) /**/;
 614       EXTEND (SP, n);
 615       for (i = 0; i < n; ++i) {
 616         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
 617         free (lines[i]);
 618       }
 619       free (lines);
 620
 621 void
 622 aug_init (g, root, flags)
 623       guestfs_h *g;
 624       char *root;
 625       int flags;
 626 PREINIT:
 627       int r;
 628  PPCODE:
 629       r = guestfs_aug_init (g, root, flags);
 630       if (r == -1)
 631         croak ("aug_init: %s", guestfs_last_error (g));
 632
 633 void
 634 aug_close (g)
 635       guestfs_h *g;
 636 PREINIT:
 637       int r;
 638  PPCODE:
 639       r = guestfs_aug_close (g);
 640       if (r == -1)
 641         croak ("aug_close: %s", guestfs_last_error (g));
 642
 643 SV *
 644 aug_defvar (g, name, expr)
 645       guestfs_h *g;
 646       char *name;
 647       char *expr;
 648 PREINIT:
 649       int nrnodes;
 650    CODE:
 651       nrnodes = guestfs_aug_defvar (g, name, expr);
 652       if (nrnodes == -1)
 653         croak ("aug_defvar: %s", guestfs_last_error (g));
 654       RETVAL = newSViv (nrnodes);
 655  OUTPUT:
 656       RETVAL
 657
 658 void
 659 aug_defnode (g, name, expr, val)
 660       guestfs_h *g;
 661       char *name;
 662       char *expr;
 663       char *val;
 664 PREINIT:
 665       struct guestfs_int_bool *r;
 666  PPCODE:
 667       r = guestfs_aug_defnode (g, name, expr, val);
 668       if (r == NULL)
 669         croak ("aug_defnode: %s", guestfs_last_error (g));
 670       EXTEND (SP, 2);
 671       PUSHs (sv_2mortal (newSViv (r->i)));
 672       PUSHs (sv_2mortal (newSViv (r->b)));
 673       guestfs_free_int_bool (r);
 674
 675 SV *
 676 aug_get (g, path)
 677       guestfs_h *g;
 678       char *path;
 679 PREINIT:
 680       char *val;
 681    CODE:
 682       val = guestfs_aug_get (g, path);
 683       if (val == NULL)
 684         croak ("aug_get: %s", guestfs_last_error (g));
 685       RETVAL = newSVpv (val, 0);
 686       free (val);
 687  OUTPUT:
 688       RETVAL
 689
 690 void
 691 aug_set (g, path, val)
 692       guestfs_h *g;
 693       char *path;
 694       char *val;
 695 PREINIT:
 696       int r;
 697  PPCODE:
 698       r = guestfs_aug_set (g, path, val);
 699       if (r == -1)
 700         croak ("aug_set: %s", guestfs_last_error (g));
 701
 702 void
 703 aug_insert (g, path, label, before)
 704       guestfs_h *g;
 705       char *path;
 706       char *label;
 707       int before;
 708 PREINIT:
 709       int r;
 710  PPCODE:
 711       r = guestfs_aug_insert (g, path, label, before);
 712       if (r == -1)
 713         croak ("aug_insert: %s", guestfs_last_error (g));
 714
 715 SV *
 716 aug_rm (g, path)
 717       guestfs_h *g;
 718       char *path;
 719 PREINIT:
 720       int nrnodes;
 721    CODE:
 722       nrnodes = guestfs_aug_rm (g, path);
 723       if (nrnodes == -1)
 724         croak ("aug_rm: %s", guestfs_last_error (g));
 725       RETVAL = newSViv (nrnodes);
 726  OUTPUT:
 727       RETVAL
 728
 729 void
 730 aug_mv (g, src, dest)
 731       guestfs_h *g;
 732       char *src;
 733       char *dest;
 734 PREINIT:
 735       int r;
 736  PPCODE:
 737       r = guestfs_aug_mv (g, src, dest);
 738       if (r == -1)
 739         croak ("aug_mv: %s", guestfs_last_error (g));
 740
 741 void
 742 aug_match (g, path)
 743       guestfs_h *g;
 744       char *path;
 745 PREINIT:
 746       char **matches;
 747       int i, n;
 748  PPCODE:
 749       matches = guestfs_aug_match (g, path);
 750       if (matches == NULL)
 751         croak ("aug_match: %s", guestfs_last_error (g));
 752       for (n = 0; matches[n] != NULL; ++n) /**/;
 753       EXTEND (SP, n);
 754       for (i = 0; i < n; ++i) {
 755         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 756         free (matches[i]);
 757       }
 758       free (matches);
 759
 760 void
 761 aug_save (g)
 762       guestfs_h *g;
 763 PREINIT:
 764       int r;
 765  PPCODE:
 766       r = guestfs_aug_save (g);
 767       if (r == -1)
 768         croak ("aug_save: %s", guestfs_last_error (g));
 769
 770 void
 771 aug_load (g)
 772       guestfs_h *g;
 773 PREINIT:
 774       int r;
 775  PPCODE:
 776       r = guestfs_aug_load (g);
 777       if (r == -1)
 778         croak ("aug_load: %s", guestfs_last_error (g));
 779
 780 void
 781 aug_ls (g, path)
 782       guestfs_h *g;
 783       char *path;
 784 PREINIT:
 785       char **matches;
 786       int i, n;
 787  PPCODE:
 788       matches = guestfs_aug_ls (g, path);
 789       if (matches == NULL)
 790         croak ("aug_ls: %s", guestfs_last_error (g));
 791       for (n = 0; matches[n] != NULL; ++n) /**/;
 792       EXTEND (SP, n);
 793       for (i = 0; i < n; ++i) {
 794         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 795         free (matches[i]);
 796       }
 797       free (matches);
 798
 799 void
 800 rm (g, path)
 801       guestfs_h *g;
 802       char *path;
 803 PREINIT:
 804       int r;
 805  PPCODE:
 806       r = guestfs_rm (g, path);
 807       if (r == -1)
 808         croak ("rm: %s", guestfs_last_error (g));
 809
 810 void
 811 rmdir (g, path)
 812       guestfs_h *g;
 813       char *path;
 814 PREINIT:
 815       int r;
 816  PPCODE:
 817       r = guestfs_rmdir (g, path);
 818       if (r == -1)
 819         croak ("rmdir: %s", guestfs_last_error (g));
 820
 821 void
 822 rm_rf (g, path)
 823       guestfs_h *g;
 824       char *path;
 825 PREINIT:
 826       int r;
 827  PPCODE:
 828       r = guestfs_rm_rf (g, path);
 829       if (r == -1)
 830         croak ("rm_rf: %s", guestfs_last_error (g));
 831
 832 void
 833 mkdir (g, path)
 834       guestfs_h *g;
 835       char *path;
 836 PREINIT:
 837       int r;
 838  PPCODE:
 839       r = guestfs_mkdir (g, path);
 840       if (r == -1)
 841         croak ("mkdir: %s", guestfs_last_error (g));
 842
 843 void
 844 mkdir_p (g, path)
 845       guestfs_h *g;
 846       char *path;
 847 PREINIT:
 848       int r;
 849  PPCODE:
 850       r = guestfs_mkdir_p (g, path);
 851       if (r == -1)
 852         croak ("mkdir_p: %s", guestfs_last_error (g));
 853
 854 void
 855 chmod (g, mode, path)
 856       guestfs_h *g;
 857       int mode;
 858       char *path;
 859 PREINIT:
 860       int r;
 861  PPCODE:
 862       r = guestfs_chmod (g, mode, path);
 863       if (r == -1)
 864         croak ("chmod: %s", guestfs_last_error (g));
 865
 866 void
 867 chown (g, owner, group, path)
 868       guestfs_h *g;
 869       int owner;
 870       int group;
 871       char *path;
 872 PREINIT:
 873       int r;
 874  PPCODE:
 875       r = guestfs_chown (g, owner, group, path);
 876       if (r == -1)
 877         croak ("chown: %s", guestfs_last_error (g));
 878
 879 SV *
 880 exists (g, path)
 881       guestfs_h *g;
 882       char *path;
 883 PREINIT:
 884       int existsflag;
 885    CODE:
 886       existsflag = guestfs_exists (g, path);
 887       if (existsflag == -1)
 888         croak ("exists: %s", guestfs_last_error (g));
 889       RETVAL = newSViv (existsflag);
 890  OUTPUT:
 891       RETVAL
 892
 893 SV *
 894 is_file (g, path)
 895       guestfs_h *g;
 896       char *path;
 897 PREINIT:
 898       int fileflag;
 899    CODE:
 900       fileflag = guestfs_is_file (g, path);
 901       if (fileflag == -1)
 902         croak ("is_file: %s", guestfs_last_error (g));
 903       RETVAL = newSViv (fileflag);
 904  OUTPUT:
 905       RETVAL
 906
 907 SV *
 908 is_dir (g, path)
 909       guestfs_h *g;
 910       char *path;
 911 PREINIT:
 912       int dirflag;
 913    CODE:
 914       dirflag = guestfs_is_dir (g, path);
 915       if (dirflag == -1)
 916         croak ("is_dir: %s", guestfs_last_error (g));
 917       RETVAL = newSViv (dirflag);
 918  OUTPUT:
 919       RETVAL
 920
 921 void
 922 pvcreate (g, device)
 923       guestfs_h *g;
 924       char *device;
 925 PREINIT:
 926       int r;
 927  PPCODE:
 928       r = guestfs_pvcreate (g, device);
 929       if (r == -1)
 930         croak ("pvcreate: %s", guestfs_last_error (g));
 931
 932 void
 933 vgcreate (g, volgroup, physvols)
 934       guestfs_h *g;
 935       char *volgroup;
 936       char **physvols;
 937 PREINIT:
 938       int r;
 939  PPCODE:
 940       r = guestfs_vgcreate (g, volgroup, physvols);
 941       free (physvols);
 942       if (r == -1)
 943         croak ("vgcreate: %s", guestfs_last_error (g));
 944
 945 void
 946 lvcreate (g, logvol, volgroup, mbytes)
 947       guestfs_h *g;
 948       char *logvol;
 949       char *volgroup;
 950       int mbytes;
 951 PREINIT:
 952       int r;
 953  PPCODE:
 954       r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
 955       if (r == -1)
 956         croak ("lvcreate: %s", guestfs_last_error (g));
 957
 958 void
 959 mkfs (g, fstype, device)
 960       guestfs_h *g;
 961       char *fstype;
 962       char *device;
 963 PREINIT:
 964       int r;
 965  PPCODE:
 966       r = guestfs_mkfs (g, fstype, device);
 967       if (r == -1)
 968         croak ("mkfs: %s", guestfs_last_error (g));
 969
 970 void
 971 sfdisk (g, device, cyls, heads, sectors, lines)
 972       guestfs_h *g;
 973       char *device;
 974       int cyls;
 975       int heads;
 976       int sectors;
 977       char **lines;
 978 PREINIT:
 979       int r;
 980  PPCODE:
 981       r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
 982       free (lines);
 983       if (r == -1)
 984         croak ("sfdisk: %s", guestfs_last_error (g));
 985
 986 void
 987 write_file (g, path, content, size)
 988       guestfs_h *g;
 989       char *path;
 990       char *content;
 991       int size;
 992 PREINIT:
 993       int r;
 994  PPCODE:
 995       r = guestfs_write_file (g, path, content, size);
 996       if (r == -1)
 997         croak ("write_file: %s", guestfs_last_error (g));
 998
 999 void
1000 umount (g, pathordevice)
1001       guestfs_h *g;
1002       char *pathordevice;
1003 PREINIT:
1004       int r;
1005  PPCODE:
1006       r = guestfs_umount (g, pathordevice);
1007       if (r == -1)
1008         croak ("umount: %s", guestfs_last_error (g));
1009
1010 void
1011 mounts (g)
1012       guestfs_h *g;
1013 PREINIT:
1014       char **devices;
1015       int i, n;
1016  PPCODE:
1017       devices = guestfs_mounts (g);
1018       if (devices == NULL)
1019         croak ("mounts: %s", guestfs_last_error (g));
1020       for (n = 0; devices[n] != NULL; ++n) /**/;
1021       EXTEND (SP, n);
1022       for (i = 0; i < n; ++i) {
1023         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
1024         free (devices[i]);
1025       }
1026       free (devices);
1027
1028 void
1029 umount_all (g)
1030       guestfs_h *g;
1031 PREINIT:
1032       int r;
1033  PPCODE:
1034       r = guestfs_umount_all (g);
1035       if (r == -1)
1036         croak ("umount_all: %s", guestfs_last_error (g));
1037
1038 void
1039 lvm_remove_all (g)
1040       guestfs_h *g;
1041 PREINIT:
1042       int r;
1043  PPCODE:
1044       r = guestfs_lvm_remove_all (g);
1045       if (r == -1)
1046         croak ("lvm_remove_all: %s", guestfs_last_error (g));
1047
1048 SV *
1049 file (g, path)
1050       guestfs_h *g;
1051       char *path;
1052 PREINIT:
1053       char *description;
1054    CODE:
1055       description = guestfs_file (g, path);
1056       if (description == NULL)
1057         croak ("file: %s", guestfs_last_error (g));
1058       RETVAL = newSVpv (description, 0);
1059       free (description);
1060  OUTPUT:
1061       RETVAL
1062
1063 SV *
1064 command (g, arguments)
1065       guestfs_h *g;
1066       char **arguments;
1067 PREINIT:
1068       char *output;
1069    CODE:
1070       output = guestfs_command (g, arguments);
1071       free (arguments);
1072       if (output == NULL)
1073         croak ("command: %s", guestfs_last_error (g));
1074       RETVAL = newSVpv (output, 0);
1075       free (output);
1076  OUTPUT:
1077       RETVAL
1078
1079 void
1080 command_lines (g, arguments)
1081       guestfs_h *g;
1082       char **arguments;
1083 PREINIT:
1084       char **lines;
1085       int i, n;
1086  PPCODE:
1087       lines = guestfs_command_lines (g, arguments);
1088       free (arguments);
1089       if (lines == NULL)
1090         croak ("command_lines: %s", guestfs_last_error (g));
1091       for (n = 0; lines[n] != NULL; ++n) /**/;
1092       EXTEND (SP, n);
1093       for (i = 0; i < n; ++i) {
1094         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
1095         free (lines[i]);
1096       }
1097       free (lines);
1098
1099 void
1100 stat (g, path)
1101       guestfs_h *g;
1102       char *path;
1103 PREINIT:
1104       struct guestfs_stat *statbuf;
1105  PPCODE:
1106       statbuf = guestfs_stat (g, path);
1107       if (statbuf == NULL)
1108         croak ("stat: %s", guestfs_last_error (g));
1109       EXTEND (SP, 13);
1110       PUSHs (sv_2mortal (my_newSVll (statbuf->dev)));
1111       PUSHs (sv_2mortal (my_newSVll (statbuf->ino)));
1112       PUSHs (sv_2mortal (my_newSVll (statbuf->mode)));
1113       PUSHs (sv_2mortal (my_newSVll (statbuf->nlink)));
1114       PUSHs (sv_2mortal (my_newSVll (statbuf->uid)));
1115       PUSHs (sv_2mortal (my_newSVll (statbuf->gid)));
1116       PUSHs (sv_2mortal (my_newSVll (statbuf->rdev)));
1117       PUSHs (sv_2mortal (my_newSVll (statbuf->size)));
1118       PUSHs (sv_2mortal (my_newSVll (statbuf->blksize)));
1119       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1120       PUSHs (sv_2mortal (my_newSVll (statbuf->atime)));
1121       PUSHs (sv_2mortal (my_newSVll (statbuf->mtime)));
1122       PUSHs (sv_2mortal (my_newSVll (statbuf->ctime)));
1123       free (statbuf);
1124
1125 void
1126 lstat (g, path)
1127       guestfs_h *g;
1128       char *path;
1129 PREINIT:
1130       struct guestfs_stat *statbuf;
1131  PPCODE:
1132       statbuf = guestfs_lstat (g, path);
1133       if (statbuf == NULL)
1134         croak ("lstat: %s", guestfs_last_error (g));
1135       EXTEND (SP, 13);
1136       PUSHs (sv_2mortal (my_newSVll (statbuf->dev)));
1137       PUSHs (sv_2mortal (my_newSVll (statbuf->ino)));
1138       PUSHs (sv_2mortal (my_newSVll (statbuf->mode)));
1139       PUSHs (sv_2mortal (my_newSVll (statbuf->nlink)));
1140       PUSHs (sv_2mortal (my_newSVll (statbuf->uid)));
1141       PUSHs (sv_2mortal (my_newSVll (statbuf->gid)));
1142       PUSHs (sv_2mortal (my_newSVll (statbuf->rdev)));
1143       PUSHs (sv_2mortal (my_newSVll (statbuf->size)));
1144       PUSHs (sv_2mortal (my_newSVll (statbuf->blksize)));
1145       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1146       PUSHs (sv_2mortal (my_newSVll (statbuf->atime)));
1147       PUSHs (sv_2mortal (my_newSVll (statbuf->mtime)));
1148       PUSHs (sv_2mortal (my_newSVll (statbuf->ctime)));
1149       free (statbuf);
1150
1151 void
1152 statvfs (g, path)
1153       guestfs_h *g;
1154       char *path;
1155 PREINIT:
1156       struct guestfs_statvfs *statbuf;
1157  PPCODE:
1158       statbuf = guestfs_statvfs (g, path);
1159       if (statbuf == NULL)
1160         croak ("statvfs: %s", guestfs_last_error (g));
1161       EXTEND (SP, 11);
1162       PUSHs (sv_2mortal (my_newSVll (statbuf->bsize)));
1163       PUSHs (sv_2mortal (my_newSVll (statbuf->frsize)));
1164       PUSHs (sv_2mortal (my_newSVll (statbuf->blocks)));
1165       PUSHs (sv_2mortal (my_newSVll (statbuf->bfree)));
1166       PUSHs (sv_2mortal (my_newSVll (statbuf->bavail)));
1167       PUSHs (sv_2mortal (my_newSVll (statbuf->files)));
1168       PUSHs (sv_2mortal (my_newSVll (statbuf->ffree)));
1169       PUSHs (sv_2mortal (my_newSVll (statbuf->favail)));
1170       PUSHs (sv_2mortal (my_newSVll (statbuf->fsid)));
1171       PUSHs (sv_2mortal (my_newSVll (statbuf->flag)));
1172       PUSHs (sv_2mortal (my_newSVll (statbuf->namemax)));
1173       free (statbuf);
1174
1175 void
1176 tune2fs_l (g, device)
1177       guestfs_h *g;
1178       char *device;
1179 PREINIT:
1180       char **superblock;
1181       int i, n;
1182  PPCODE:
1183       superblock = guestfs_tune2fs_l (g, device);
1184       if (superblock == NULL)
1185         croak ("tune2fs_l: %s", guestfs_last_error (g));
1186       for (n = 0; superblock[n] != NULL; ++n) /**/;
1187       EXTEND (SP, n);
1188       for (i = 0; i < n; ++i) {
1189         PUSHs (sv_2mortal (newSVpv (superblock[i], 0)));
1190         free (superblock[i]);
1191       }
1192       free (superblock);
1193
1194 void
1195 blockdev_setro (g, device)
1196       guestfs_h *g;
1197       char *device;
1198 PREINIT:
1199       int r;
1200  PPCODE:
1201       r = guestfs_blockdev_setro (g, device);
1202       if (r == -1)
1203         croak ("blockdev_setro: %s", guestfs_last_error (g));
1204
1205 void
1206 blockdev_setrw (g, device)
1207       guestfs_h *g;
1208       char *device;
1209 PREINIT:
1210       int r;
1211  PPCODE:
1212       r = guestfs_blockdev_setrw (g, device);
1213       if (r == -1)
1214         croak ("blockdev_setrw: %s", guestfs_last_error (g));
1215
1216 SV *
1217 blockdev_getro (g, device)
1218       guestfs_h *g;
1219       char *device;
1220 PREINIT:
1221       int ro;
1222    CODE:
1223       ro = guestfs_blockdev_getro (g, device);
1224       if (ro == -1)
1225         croak ("blockdev_getro: %s", guestfs_last_error (g));
1226       RETVAL = newSViv (ro);
1227  OUTPUT:
1228       RETVAL
1229
1230 SV *
1231 blockdev_getss (g, device)
1232       guestfs_h *g;
1233       char *device;
1234 PREINIT:
1235       int sectorsize;
1236    CODE:
1237       sectorsize = guestfs_blockdev_getss (g, device);
1238       if (sectorsize == -1)
1239         croak ("blockdev_getss: %s", guestfs_last_error (g));
1240       RETVAL = newSViv (sectorsize);
1241  OUTPUT:
1242       RETVAL
1243
1244 SV *
1245 blockdev_getbsz (g, device)
1246       guestfs_h *g;
1247       char *device;
1248 PREINIT:
1249       int blocksize;
1250    CODE:
1251       blocksize = guestfs_blockdev_getbsz (g, device);
1252       if (blocksize == -1)
1253         croak ("blockdev_getbsz: %s", guestfs_last_error (g));
1254       RETVAL = newSViv (blocksize);
1255  OUTPUT:
1256       RETVAL
1257
1258 void
1259 blockdev_setbsz (g, device, blocksize)
1260       guestfs_h *g;
1261       char *device;
1262       int blocksize;
1263 PREINIT:
1264       int r;
1265  PPCODE:
1266       r = guestfs_blockdev_setbsz (g, device, blocksize);
1267       if (r == -1)
1268         croak ("blockdev_setbsz: %s", guestfs_last_error (g));
1269
1270 SV *
1271 blockdev_getsz (g, device)
1272       guestfs_h *g;
1273       char *device;
1274 PREINIT:
1275       int64_t sizeinsectors;
1276    CODE:
1277       sizeinsectors = guestfs_blockdev_getsz (g, device);
1278       if (sizeinsectors == -1)
1279         croak ("blockdev_getsz: %s", guestfs_last_error (g));
1280       RETVAL = my_newSVll (sizeinsectors);
1281  OUTPUT:
1282       RETVAL
1283
1284 SV *
1285 blockdev_getsize64 (g, device)
1286       guestfs_h *g;
1287       char *device;
1288 PREINIT:
1289       int64_t sizeinbytes;
1290    CODE:
1291       sizeinbytes = guestfs_blockdev_getsize64 (g, device);
1292       if (sizeinbytes == -1)
1293         croak ("blockdev_getsize64: %s", guestfs_last_error (g));
1294       RETVAL = my_newSVll (sizeinbytes);
1295  OUTPUT:
1296       RETVAL
1297
1298 void
1299 blockdev_flushbufs (g, device)
1300       guestfs_h *g;
1301       char *device;
1302 PREINIT:
1303       int r;
1304  PPCODE:
1305       r = guestfs_blockdev_flushbufs (g, device);
1306       if (r == -1)
1307         croak ("blockdev_flushbufs: %s", guestfs_last_error (g));
1308
1309 void
1310 blockdev_rereadpt (g, device)
1311       guestfs_h *g;
1312       char *device;
1313 PREINIT:
1314       int r;
1315  PPCODE:
1316       r = guestfs_blockdev_rereadpt (g, device);
1317       if (r == -1)
1318         croak ("blockdev_rereadpt: %s", guestfs_last_error (g));
1319
1320 void
1321 upload (g, filename, remotefilename)
1322       guestfs_h *g;
1323       char *filename;
1324       char *remotefilename;
1325 PREINIT:
1326       int r;
1327  PPCODE:
1328       r = guestfs_upload (g, filename, remotefilename);
1329       if (r == -1)
1330         croak ("upload: %s", guestfs_last_error (g));
1331
1332 void
1333 download (g, remotefilename, filename)
1334       guestfs_h *g;
1335       char *remotefilename;
1336       char *filename;
1337 PREINIT:
1338       int r;
1339  PPCODE:
1340       r = guestfs_download (g, remotefilename, filename);
1341       if (r == -1)
1342         croak ("download: %s", guestfs_last_error (g));
1343
1344 SV *
1345 checksum (g, csumtype, path)
1346       guestfs_h *g;
1347       char *csumtype;
1348       char *path;
1349 PREINIT:
1350       char *checksum;
1351    CODE:
1352       checksum = guestfs_checksum (g, csumtype, path);
1353       if (checksum == NULL)
1354         croak ("checksum: %s", guestfs_last_error (g));
1355       RETVAL = newSVpv (checksum, 0);
1356       free (checksum);
1357  OUTPUT:
1358       RETVAL
1359
1360 void
1361 tar_in (g, tarfile, directory)
1362       guestfs_h *g;
1363       char *tarfile;
1364       char *directory;
1365 PREINIT:
1366       int r;
1367  PPCODE:
1368       r = guestfs_tar_in (g, tarfile, directory);
1369       if (r == -1)
1370         croak ("tar_in: %s", guestfs_last_error (g));
1371
1372 void
1373 tar_out (g, directory, tarfile)
1374       guestfs_h *g;
1375       char *directory;
1376       char *tarfile;
1377 PREINIT:
1378       int r;
1379  PPCODE:
1380       r = guestfs_tar_out (g, directory, tarfile);
1381       if (r == -1)
1382         croak ("tar_out: %s", guestfs_last_error (g));
1383
1384 void
1385 tgz_in (g, tarball, directory)
1386       guestfs_h *g;
1387       char *tarball;
1388       char *directory;
1389 PREINIT:
1390       int r;
1391  PPCODE:
1392       r = guestfs_tgz_in (g, tarball, directory);
1393       if (r == -1)
1394         croak ("tgz_in: %s", guestfs_last_error (g));
1395
1396 void
1397 tgz_out (g, directory, tarball)
1398       guestfs_h *g;
1399       char *directory;
1400       char *tarball;
1401 PREINIT:
1402       int r;
1403  PPCODE:
1404       r = guestfs_tgz_out (g, directory, tarball);
1405       if (r == -1)
1406         croak ("tgz_out: %s", guestfs_last_error (g));
1407