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       }
 191       RETVAL = newSVpv (path, 0);
 192  OUTPUT:
 193       RETVAL
 194
 195 void
 196 set_autosync (g, autosync)
 197       guestfs_h *g;
 198       int autosync;
 199 PREINIT:
 200       int r;
 201  PPCODE:
 202       r = guestfs_set_autosync (g, autosync);
 203       if (r == -1)
 204         croak ("set_autosync: %s", guestfs_last_error (g));
 205
 206 SV *
 207 get_autosync (g)
 208       guestfs_h *g;
 209 PREINIT:
 210       int autosync;
 211    CODE:
 212       autosync = guestfs_get_autosync (g);
 213       if (autosync == -1) {
 214         croak ("get_autosync: %s", guestfs_last_error (g));
 215       }
 216       RETVAL = newSViv (autosync);
 217  OUTPUT:
 218       RETVAL
 219
 220 void
 221 set_verbose (g, verbose)
 222       guestfs_h *g;
 223       int verbose;
 224 PREINIT:
 225       int r;
 226  PPCODE:
 227       r = guestfs_set_verbose (g, verbose);
 228       if (r == -1)
 229         croak ("set_verbose: %s", guestfs_last_error (g));
 230
 231 SV *
 232 get_verbose (g)
 233       guestfs_h *g;
 234 PREINIT:
 235       int verbose;
 236    CODE:
 237       verbose = guestfs_get_verbose (g);
 238       if (verbose == -1) {
 239         croak ("get_verbose: %s", guestfs_last_error (g));
 240       }
 241       RETVAL = newSViv (verbose);
 242  OUTPUT:
 243       RETVAL
 244
 245 void
 246 mount (g, device, mountpoint)
 247       guestfs_h *g;
 248       char *device;
 249       char *mountpoint;
 250 PREINIT:
 251       int r;
 252  PPCODE:
 253       r = guestfs_mount (g, device, mountpoint);
 254       if (r == -1)
 255         croak ("mount: %s", guestfs_last_error (g));
 256
 257 void
 258 sync (g)
 259       guestfs_h *g;
 260 PREINIT:
 261       int r;
 262  PPCODE:
 263       r = guestfs_sync (g);
 264       if (r == -1)
 265         croak ("sync: %s", guestfs_last_error (g));
 266
 267 void
 268 touch (g, path)
 269       guestfs_h *g;
 270       char *path;
 271 PREINIT:
 272       int r;
 273  PPCODE:
 274       r = guestfs_touch (g, path);
 275       if (r == -1)
 276         croak ("touch: %s", guestfs_last_error (g));
 277
 278 SV *
 279 cat (g, path)
 280       guestfs_h *g;
 281       char *path;
 282 PREINIT:
 283       char *content;
 284    CODE:
 285       content = guestfs_cat (g, path);
 286       if (content == NULL) {
 287         croak ("cat: %s", guestfs_last_error (g));
 288       }
 289       RETVAL = newSVpv (content, 0);
 290       free (content);
 291  OUTPUT:
 292       RETVAL
 293
 294 SV *
 295 ll (g, directory)
 296       guestfs_h *g;
 297       char *directory;
 298 PREINIT:
 299       char *listing;
 300    CODE:
 301       listing = guestfs_ll (g, directory);
 302       if (listing == NULL) {
 303         croak ("ll: %s", guestfs_last_error (g));
 304       }
 305       RETVAL = newSVpv (listing, 0);
 306       free (listing);
 307  OUTPUT:
 308       RETVAL
 309
 310 void
 311 ls (g, directory)
 312       guestfs_h *g;
 313       char *directory;
 314 PREINIT:
 315       char **listing;
 316       int i, n;
 317  PPCODE:
 318       listing = guestfs_ls (g, directory);
 319       if (listing == NULL) {
 320         croak ("ls: %s", guestfs_last_error (g));
 321       }
 322       for (n = 0; listing[n] != NULL; ++n) /**/;
 323       EXTEND (SP, n);
 324       for (i = 0; i < n; ++i) {
 325         PUSHs (sv_2mortal (newSVpv (listing[i], 0)));
 326         free (listing[i]);
 327       }
 328       free (listing);
 329
 330 void
 331 list_devices (g)
 332       guestfs_h *g;
 333 PREINIT:
 334       char **devices;
 335       int i, n;
 336  PPCODE:
 337       devices = guestfs_list_devices (g);
 338       if (devices == NULL) {
 339         croak ("list_devices: %s", guestfs_last_error (g));
 340       }
 341       for (n = 0; devices[n] != NULL; ++n) /**/;
 342       EXTEND (SP, n);
 343       for (i = 0; i < n; ++i) {
 344         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
 345         free (devices[i]);
 346       }
 347       free (devices);
 348
 349 void
 350 list_partitions (g)
 351       guestfs_h *g;
 352 PREINIT:
 353       char **partitions;
 354       int i, n;
 355  PPCODE:
 356       partitions = guestfs_list_partitions (g);
 357       if (partitions == NULL) {
 358         croak ("list_partitions: %s", guestfs_last_error (g));
 359       }
 360       for (n = 0; partitions[n] != NULL; ++n) /**/;
 361       EXTEND (SP, n);
 362       for (i = 0; i < n; ++i) {
 363         PUSHs (sv_2mortal (newSVpv (partitions[i], 0)));
 364         free (partitions[i]);
 365       }
 366       free (partitions);
 367
 368 void
 369 pvs (g)
 370       guestfs_h *g;
 371 PREINIT:
 372       char **physvols;
 373       int i, n;
 374  PPCODE:
 375       physvols = guestfs_pvs (g);
 376       if (physvols == NULL) {
 377         croak ("pvs: %s", guestfs_last_error (g));
 378       }
 379       for (n = 0; physvols[n] != NULL; ++n) /**/;
 380       EXTEND (SP, n);
 381       for (i = 0; i < n; ++i) {
 382         PUSHs (sv_2mortal (newSVpv (physvols[i], 0)));
 383         free (physvols[i]);
 384       }
 385       free (physvols);
 386
 387 void
 388 vgs (g)
 389       guestfs_h *g;
 390 PREINIT:
 391       char **volgroups;
 392       int i, n;
 393  PPCODE:
 394       volgroups = guestfs_vgs (g);
 395       if (volgroups == NULL) {
 396         croak ("vgs: %s", guestfs_last_error (g));
 397       }
 398       for (n = 0; volgroups[n] != NULL; ++n) /**/;
 399       EXTEND (SP, n);
 400       for (i = 0; i < n; ++i) {
 401         PUSHs (sv_2mortal (newSVpv (volgroups[i], 0)));
 402         free (volgroups[i]);
 403       }
 404       free (volgroups);
 405
 406 void
 407 lvs (g)
 408       guestfs_h *g;
 409 PREINIT:
 410       char **logvols;
 411       int i, n;
 412  PPCODE:
 413       logvols = guestfs_lvs (g);
 414       if (logvols == NULL) {
 415         croak ("lvs: %s", guestfs_last_error (g));
 416       }
 417       for (n = 0; logvols[n] != NULL; ++n) /**/;
 418       EXTEND (SP, n);
 419       for (i = 0; i < n; ++i) {
 420         PUSHs (sv_2mortal (newSVpv (logvols[i], 0)));
 421         free (logvols[i]);
 422       }
 423       free (logvols);
 424
 425 void
 426 pvs_full (g)
 427       guestfs_h *g;
 428 PREINIT:
 429       struct guestfs_lvm_pv_list *physvols;
 430       int i;
 431       HV *hv;
 432  PPCODE:
 433       physvols = guestfs_pvs_full (g);
 434       if (physvols == NULL) {
 435         croak ("pvs_full: %s", guestfs_last_error (g));
 436       }
 437       EXTEND (SP, physvols->len);
 438       for (i = 0; i < physvols->len; ++i) {
 439         hv = newHV ();
 440         (void) hv_store (hv, "pv_name", 7, newSVpv (physvols->val[i].pv_name, 0), 0);
 441         (void) hv_store (hv, "pv_uuid", 7, newSVpv (physvols->val[i].pv_uuid, 32), 0);
 442         (void) hv_store (hv, "pv_fmt", 6, newSVpv (physvols->val[i].pv_fmt, 0), 0);
 443         (void) hv_store (hv, "pv_size", 7, my_newSVull (physvols->val[i].pv_size), 0);
 444         (void) hv_store (hv, "dev_size", 8, my_newSVull (physvols->val[i].dev_size), 0);
 445         (void) hv_store (hv, "pv_free", 7, my_newSVull (physvols->val[i].pv_free), 0);
 446         (void) hv_store (hv, "pv_used", 7, my_newSVull (physvols->val[i].pv_used), 0);
 447         (void) hv_store (hv, "pv_attr", 7, newSVpv (physvols->val[i].pv_attr, 0), 0);
 448         (void) hv_store (hv, "pv_pe_count", 11, my_newSVll (physvols->val[i].pv_pe_count), 0);
 449         (void) hv_store (hv, "pv_pe_alloc_count", 17, my_newSVll (physvols->val[i].pv_pe_alloc_count), 0);
 450         (void) hv_store (hv, "pv_tags", 7, newSVpv (physvols->val[i].pv_tags, 0), 0);
 451         (void) hv_store (hv, "pe_start", 8, my_newSVull (physvols->val[i].pe_start), 0);
 452         (void) hv_store (hv, "pv_mda_count", 12, my_newSVll (physvols->val[i].pv_mda_count), 0);
 453         (void) hv_store (hv, "pv_mda_free", 11, my_newSVull (physvols->val[i].pv_mda_free), 0);
 454         PUSHs (sv_2mortal ((SV *) hv));
 455       }
 456       guestfs_free_lvm_pv_list (physvols);
 457
 458 void
 459 vgs_full (g)
 460       guestfs_h *g;
 461 PREINIT:
 462       struct guestfs_lvm_vg_list *volgroups;
 463       int i;
 464       HV *hv;
 465  PPCODE:
 466       volgroups = guestfs_vgs_full (g);
 467       if (volgroups == NULL) {
 468         croak ("vgs_full: %s", guestfs_last_error (g));
 469       }
 470       EXTEND (SP, volgroups->len);
 471       for (i = 0; i < volgroups->len; ++i) {
 472         hv = newHV ();
 473         (void) hv_store (hv, "vg_name", 7, newSVpv (volgroups->val[i].vg_name, 0), 0);
 474         (void) hv_store (hv, "vg_uuid", 7, newSVpv (volgroups->val[i].vg_uuid, 32), 0);
 475         (void) hv_store (hv, "vg_fmt", 6, newSVpv (volgroups->val[i].vg_fmt, 0), 0);
 476         (void) hv_store (hv, "vg_attr", 7, newSVpv (volgroups->val[i].vg_attr, 0), 0);
 477         (void) hv_store (hv, "vg_size", 7, my_newSVull (volgroups->val[i].vg_size), 0);
 478         (void) hv_store (hv, "vg_free", 7, my_newSVull (volgroups->val[i].vg_free), 0);
 479         (void) hv_store (hv, "vg_sysid", 8, newSVpv (volgroups->val[i].vg_sysid, 0), 0);
 480         (void) hv_store (hv, "vg_extent_size", 14, my_newSVull (volgroups->val[i].vg_extent_size), 0);
 481         (void) hv_store (hv, "vg_extent_count", 15, my_newSVll (volgroups->val[i].vg_extent_count), 0);
 482         (void) hv_store (hv, "vg_free_count", 13, my_newSVll (volgroups->val[i].vg_free_count), 0);
 483         (void) hv_store (hv, "max_lv", 6, my_newSVll (volgroups->val[i].max_lv), 0);
 484         (void) hv_store (hv, "max_pv", 6, my_newSVll (volgroups->val[i].max_pv), 0);
 485         (void) hv_store (hv, "pv_count", 8, my_newSVll (volgroups->val[i].pv_count), 0);
 486         (void) hv_store (hv, "lv_count", 8, my_newSVll (volgroups->val[i].lv_count), 0);
 487         (void) hv_store (hv, "snap_count", 10, my_newSVll (volgroups->val[i].snap_count), 0);
 488         (void) hv_store (hv, "vg_seqno", 8, my_newSVll (volgroups->val[i].vg_seqno), 0);
 489         (void) hv_store (hv, "vg_tags", 7, newSVpv (volgroups->val[i].vg_tags, 0), 0);
 490         (void) hv_store (hv, "vg_mda_count", 12, my_newSVll (volgroups->val[i].vg_mda_count), 0);
 491         (void) hv_store (hv, "vg_mda_free", 11, my_newSVull (volgroups->val[i].vg_mda_free), 0);
 492         PUSHs (sv_2mortal ((SV *) hv));
 493       }
 494       guestfs_free_lvm_vg_list (volgroups);
 495
 496 void
 497 lvs_full (g)
 498       guestfs_h *g;
 499 PREINIT:
 500       struct guestfs_lvm_lv_list *logvols;
 501       int i;
 502       HV *hv;
 503  PPCODE:
 504       logvols = guestfs_lvs_full (g);
 505       if (logvols == NULL) {
 506         croak ("lvs_full: %s", guestfs_last_error (g));
 507       }
 508       EXTEND (SP, logvols->len);
 509       for (i = 0; i < logvols->len; ++i) {
 510         hv = newHV ();
 511         (void) hv_store (hv, "lv_name", 7, newSVpv (logvols->val[i].lv_name, 0), 0);
 512         (void) hv_store (hv, "lv_uuid", 7, newSVpv (logvols->val[i].lv_uuid, 32), 0);
 513         (void) hv_store (hv, "lv_attr", 7, newSVpv (logvols->val[i].lv_attr, 0), 0);
 514         (void) hv_store (hv, "lv_major", 8, my_newSVll (logvols->val[i].lv_major), 0);
 515         (void) hv_store (hv, "lv_minor", 8, my_newSVll (logvols->val[i].lv_minor), 0);
 516         (void) hv_store (hv, "lv_kernel_major", 15, my_newSVll (logvols->val[i].lv_kernel_major), 0);
 517         (void) hv_store (hv, "lv_kernel_minor", 15, my_newSVll (logvols->val[i].lv_kernel_minor), 0);
 518         (void) hv_store (hv, "lv_size", 7, my_newSVull (logvols->val[i].lv_size), 0);
 519         (void) hv_store (hv, "seg_count", 9, my_newSVll (logvols->val[i].seg_count), 0);
 520         (void) hv_store (hv, "origin", 6, newSVpv (logvols->val[i].origin, 0), 0);
 521         (void) hv_store (hv, "snap_percent", 12, newSVnv (logvols->val[i].snap_percent), 0);
 522         (void) hv_store (hv, "copy_percent", 12, newSVnv (logvols->val[i].copy_percent), 0);
 523         (void) hv_store (hv, "move_pv", 7, newSVpv (logvols->val[i].move_pv, 0), 0);
 524         (void) hv_store (hv, "lv_tags", 7, newSVpv (logvols->val[i].lv_tags, 0), 0);
 525         (void) hv_store (hv, "mirror_log", 10, newSVpv (logvols->val[i].mirror_log, 0), 0);
 526         (void) hv_store (hv, "modules", 7, newSVpv (logvols->val[i].modules, 0), 0);
 527         PUSHs (sv_2mortal ((SV *) hv));
 528       }
 529       guestfs_free_lvm_lv_list (logvols);
 530
 531 void
 532 read_lines (g, path)
 533       guestfs_h *g;
 534       char *path;
 535 PREINIT:
 536       char **lines;
 537       int i, n;
 538  PPCODE:
 539       lines = guestfs_read_lines (g, path);
 540       if (lines == NULL) {
 541         croak ("read_lines: %s", guestfs_last_error (g));
 542       }
 543       for (n = 0; lines[n] != NULL; ++n) /**/;
 544       EXTEND (SP, n);
 545       for (i = 0; i < n; ++i) {
 546         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
 547         free (lines[i]);
 548       }
 549       free (lines);
 550
 551 void
 552 aug_init (g, root, flags)
 553       guestfs_h *g;
 554       char *root;
 555       int flags;
 556 PREINIT:
 557       int r;
 558  PPCODE:
 559       r = guestfs_aug_init (g, root, flags);
 560       if (r == -1)
 561         croak ("aug_init: %s", guestfs_last_error (g));
 562
 563 void
 564 aug_close (g)
 565       guestfs_h *g;
 566 PREINIT:
 567       int r;
 568  PPCODE:
 569       r = guestfs_aug_close (g);
 570       if (r == -1)
 571         croak ("aug_close: %s", guestfs_last_error (g));
 572
 573 SV *
 574 aug_defvar (g, name, expr)
 575       guestfs_h *g;
 576       char *name;
 577       char *expr;
 578 PREINIT:
 579       int nrnodes;
 580    CODE:
 581       nrnodes = guestfs_aug_defvar (g, name, expr);
 582       if (nrnodes == -1) {
 583         croak ("aug_defvar: %s", guestfs_last_error (g));
 584       }
 585       RETVAL = newSViv (nrnodes);
 586  OUTPUT:
 587       RETVAL
 588
 589 void
 590 aug_defnode (g, name, expr, val)
 591       guestfs_h *g;
 592       char *name;
 593       char *expr;
 594       char *val;
 595 PREINIT:
 596       struct guestfs_int_bool *r;
 597  PPCODE:
 598       r = guestfs_aug_defnode (g, name, expr, val);
 599       if (r == NULL) {
 600         croak ("aug_defnode: %s", guestfs_last_error (g));
 601       }
 602       EXTEND (SP, 2);
 603       PUSHs (sv_2mortal (newSViv (r->i)));
 604       PUSHs (sv_2mortal (newSViv (r->b)));
 605       guestfs_free_int_bool (r);
 606
 607 SV *
 608 aug_get (g, path)
 609       guestfs_h *g;
 610       char *path;
 611 PREINIT:
 612       char *val;
 613    CODE:
 614       val = guestfs_aug_get (g, path);
 615       if (val == NULL) {
 616         croak ("aug_get: %s", guestfs_last_error (g));
 617       }
 618       RETVAL = newSVpv (val, 0);
 619       free (val);
 620  OUTPUT:
 621       RETVAL
 622
 623 void
 624 aug_set (g, path, val)
 625       guestfs_h *g;
 626       char *path;
 627       char *val;
 628 PREINIT:
 629       int r;
 630  PPCODE:
 631       r = guestfs_aug_set (g, path, val);
 632       if (r == -1)
 633         croak ("aug_set: %s", guestfs_last_error (g));
 634
 635 void
 636 aug_insert (g, path, label, before)
 637       guestfs_h *g;
 638       char *path;
 639       char *label;
 640       int before;
 641 PREINIT:
 642       int r;
 643  PPCODE:
 644       r = guestfs_aug_insert (g, path, label, before);
 645       if (r == -1)
 646         croak ("aug_insert: %s", guestfs_last_error (g));
 647
 648 SV *
 649 aug_rm (g, path)
 650       guestfs_h *g;
 651       char *path;
 652 PREINIT:
 653       int nrnodes;
 654    CODE:
 655       nrnodes = guestfs_aug_rm (g, path);
 656       if (nrnodes == -1) {
 657         croak ("aug_rm: %s", guestfs_last_error (g));
 658       }
 659       RETVAL = newSViv (nrnodes);
 660  OUTPUT:
 661       RETVAL
 662
 663 void
 664 aug_mv (g, src, dest)
 665       guestfs_h *g;
 666       char *src;
 667       char *dest;
 668 PREINIT:
 669       int r;
 670  PPCODE:
 671       r = guestfs_aug_mv (g, src, dest);
 672       if (r == -1)
 673         croak ("aug_mv: %s", guestfs_last_error (g));
 674
 675 void
 676 aug_match (g, path)
 677       guestfs_h *g;
 678       char *path;
 679 PREINIT:
 680       char **matches;
 681       int i, n;
 682  PPCODE:
 683       matches = guestfs_aug_match (g, path);
 684       if (matches == NULL) {
 685         croak ("aug_match: %s", guestfs_last_error (g));
 686       }
 687       for (n = 0; matches[n] != NULL; ++n) /**/;
 688       EXTEND (SP, n);
 689       for (i = 0; i < n; ++i) {
 690         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 691         free (matches[i]);
 692       }
 693       free (matches);
 694
 695 void
 696 aug_save (g)
 697       guestfs_h *g;
 698 PREINIT:
 699       int r;
 700  PPCODE:
 701       r = guestfs_aug_save (g);
 702       if (r == -1)
 703         croak ("aug_save: %s", guestfs_last_error (g));
 704
 705 void
 706 aug_load (g)
 707       guestfs_h *g;
 708 PREINIT:
 709       int r;
 710  PPCODE:
 711       r = guestfs_aug_load (g);
 712       if (r == -1)
 713         croak ("aug_load: %s", guestfs_last_error (g));
 714
 715 void
 716 aug_ls (g, path)
 717       guestfs_h *g;
 718       char *path;
 719 PREINIT:
 720       char **matches;
 721       int i, n;
 722  PPCODE:
 723       matches = guestfs_aug_ls (g, path);
 724       if (matches == NULL) {
 725         croak ("aug_ls: %s", guestfs_last_error (g));
 726       }
 727       for (n = 0; matches[n] != NULL; ++n) /**/;
 728       EXTEND (SP, n);
 729       for (i = 0; i < n; ++i) {
 730         PUSHs (sv_2mortal (newSVpv (matches[i], 0)));
 731         free (matches[i]);
 732       }
 733       free (matches);
 734
 735 void
 736 rm (g, path)
 737       guestfs_h *g;
 738       char *path;
 739 PREINIT:
 740       int r;
 741  PPCODE:
 742       r = guestfs_rm (g, path);
 743       if (r == -1)
 744         croak ("rm: %s", guestfs_last_error (g));
 745
 746 void
 747 rmdir (g, path)
 748       guestfs_h *g;
 749       char *path;
 750 PREINIT:
 751       int r;
 752  PPCODE:
 753       r = guestfs_rmdir (g, path);
 754       if (r == -1)
 755         croak ("rmdir: %s", guestfs_last_error (g));
 756
 757 void
 758 rm_rf (g, path)
 759       guestfs_h *g;
 760       char *path;
 761 PREINIT:
 762       int r;
 763  PPCODE:
 764       r = guestfs_rm_rf (g, path);
 765       if (r == -1)
 766         croak ("rm_rf: %s", guestfs_last_error (g));
 767
 768 void
 769 mkdir (g, path)
 770       guestfs_h *g;
 771       char *path;
 772 PREINIT:
 773       int r;
 774  PPCODE:
 775       r = guestfs_mkdir (g, path);
 776       if (r == -1)
 777         croak ("mkdir: %s", guestfs_last_error (g));
 778
 779 void
 780 mkdir_p (g, path)
 781       guestfs_h *g;
 782       char *path;
 783 PREINIT:
 784       int r;
 785  PPCODE:
 786       r = guestfs_mkdir_p (g, path);
 787       if (r == -1)
 788         croak ("mkdir_p: %s", guestfs_last_error (g));
 789
 790 void
 791 chmod (g, mode, path)
 792       guestfs_h *g;
 793       int mode;
 794       char *path;
 795 PREINIT:
 796       int r;
 797  PPCODE:
 798       r = guestfs_chmod (g, mode, path);
 799       if (r == -1)
 800         croak ("chmod: %s", guestfs_last_error (g));
 801
 802 void
 803 chown (g, owner, group, path)
 804       guestfs_h *g;
 805       int owner;
 806       int group;
 807       char *path;
 808 PREINIT:
 809       int r;
 810  PPCODE:
 811       r = guestfs_chown (g, owner, group, path);
 812       if (r == -1)
 813         croak ("chown: %s", guestfs_last_error (g));
 814
 815 SV *
 816 exists (g, path)
 817       guestfs_h *g;
 818       char *path;
 819 PREINIT:
 820       int existsflag;
 821    CODE:
 822       existsflag = guestfs_exists (g, path);
 823       if (existsflag == -1) {
 824         croak ("exists: %s", guestfs_last_error (g));
 825       }
 826       RETVAL = newSViv (existsflag);
 827  OUTPUT:
 828       RETVAL
 829
 830 SV *
 831 is_file (g, path)
 832       guestfs_h *g;
 833       char *path;
 834 PREINIT:
 835       int fileflag;
 836    CODE:
 837       fileflag = guestfs_is_file (g, path);
 838       if (fileflag == -1) {
 839         croak ("is_file: %s", guestfs_last_error (g));
 840       }
 841       RETVAL = newSViv (fileflag);
 842  OUTPUT:
 843       RETVAL
 844
 845 SV *
 846 is_dir (g, path)
 847       guestfs_h *g;
 848       char *path;
 849 PREINIT:
 850       int dirflag;
 851    CODE:
 852       dirflag = guestfs_is_dir (g, path);
 853       if (dirflag == -1) {
 854         croak ("is_dir: %s", guestfs_last_error (g));
 855       }
 856       RETVAL = newSViv (dirflag);
 857  OUTPUT:
 858       RETVAL
 859
 860 void
 861 pvcreate (g, device)
 862       guestfs_h *g;
 863       char *device;
 864 PREINIT:
 865       int r;
 866  PPCODE:
 867       r = guestfs_pvcreate (g, device);
 868       if (r == -1)
 869         croak ("pvcreate: %s", guestfs_last_error (g));
 870
 871 void
 872 vgcreate (g, volgroup, physvols)
 873       guestfs_h *g;
 874       char *volgroup;
 875       char **physvols;
 876 PREINIT:
 877       int r;
 878  PPCODE:
 879       r = guestfs_vgcreate (g, volgroup, physvols);
 880       free (physvols);
 881       if (r == -1)
 882         croak ("vgcreate: %s", guestfs_last_error (g));
 883
 884 void
 885 lvcreate (g, logvol, volgroup, mbytes)
 886       guestfs_h *g;
 887       char *logvol;
 888       char *volgroup;
 889       int mbytes;
 890 PREINIT:
 891       int r;
 892  PPCODE:
 893       r = guestfs_lvcreate (g, logvol, volgroup, mbytes);
 894       if (r == -1)
 895         croak ("lvcreate: %s", guestfs_last_error (g));
 896
 897 void
 898 mkfs (g, fstype, device)
 899       guestfs_h *g;
 900       char *fstype;
 901       char *device;
 902 PREINIT:
 903       int r;
 904  PPCODE:
 905       r = guestfs_mkfs (g, fstype, device);
 906       if (r == -1)
 907         croak ("mkfs: %s", guestfs_last_error (g));
 908
 909 void
 910 sfdisk (g, device, cyls, heads, sectors, lines)
 911       guestfs_h *g;
 912       char *device;
 913       int cyls;
 914       int heads;
 915       int sectors;
 916       char **lines;
 917 PREINIT:
 918       int r;
 919  PPCODE:
 920       r = guestfs_sfdisk (g, device, cyls, heads, sectors, lines);
 921       free (lines);
 922       if (r == -1)
 923         croak ("sfdisk: %s", guestfs_last_error (g));
 924
 925 void
 926 write_file (g, path, content, size)
 927       guestfs_h *g;
 928       char *path;
 929       char *content;
 930       int size;
 931 PREINIT:
 932       int r;
 933  PPCODE:
 934       r = guestfs_write_file (g, path, content, size);
 935       if (r == -1)
 936         croak ("write_file: %s", guestfs_last_error (g));
 937
 938 void
 939 umount (g, pathordevice)
 940       guestfs_h *g;
 941       char *pathordevice;
 942 PREINIT:
 943       int r;
 944  PPCODE:
 945       r = guestfs_umount (g, pathordevice);
 946       if (r == -1)
 947         croak ("umount: %s", guestfs_last_error (g));
 948
 949 void
 950 mounts (g)
 951       guestfs_h *g;
 952 PREINIT:
 953       char **devices;
 954       int i, n;
 955  PPCODE:
 956       devices = guestfs_mounts (g);
 957       if (devices == NULL) {
 958         croak ("mounts: %s", guestfs_last_error (g));
 959       }
 960       for (n = 0; devices[n] != NULL; ++n) /**/;
 961       EXTEND (SP, n);
 962       for (i = 0; i < n; ++i) {
 963         PUSHs (sv_2mortal (newSVpv (devices[i], 0)));
 964         free (devices[i]);
 965       }
 966       free (devices);
 967
 968 void
 969 umount_all (g)
 970       guestfs_h *g;
 971 PREINIT:
 972       int r;
 973  PPCODE:
 974       r = guestfs_umount_all (g);
 975       if (r == -1)
 976         croak ("umount_all: %s", guestfs_last_error (g));
 977
 978 void
 979 lvm_remove_all (g)
 980       guestfs_h *g;
 981 PREINIT:
 982       int r;
 983  PPCODE:
 984       r = guestfs_lvm_remove_all (g);
 985       if (r == -1)
 986         croak ("lvm_remove_all: %s", guestfs_last_error (g));
 987
 988 SV *
 989 file (g, path)
 990       guestfs_h *g;
 991       char *path;
 992 PREINIT:
 993       char *description;
 994    CODE:
 995       description = guestfs_file (g, path);
 996       if (description == NULL) {
 997         croak ("file: %s", guestfs_last_error (g));
 998       }
 999       RETVAL = newSVpv (description, 0);
1000       free (description);
1001  OUTPUT:
1002       RETVAL
1003
1004 SV *
1005 command (g, arguments)
1006       guestfs_h *g;
1007       char **arguments;
1008 PREINIT:
1009       char *output;
1010    CODE:
1011       output = guestfs_command (g, arguments);
1012       free (arguments);
1013       if (output == NULL) {
1014         croak ("command: %s", guestfs_last_error (g));
1015       }
1016       RETVAL = newSVpv (output, 0);
1017       free (output);
1018  OUTPUT:
1019       RETVAL
1020
1021 void
1022 command_lines (g, arguments)
1023       guestfs_h *g;
1024       char **arguments;
1025 PREINIT:
1026       char **lines;
1027       int i, n;
1028  PPCODE:
1029       lines = guestfs_command_lines (g, arguments);
1030       free (arguments);
1031       if (lines == NULL) {
1032         croak ("command_lines: %s", guestfs_last_error (g));
1033       }
1034       for (n = 0; lines[n] != NULL; ++n) /**/;
1035       EXTEND (SP, n);
1036       for (i = 0; i < n; ++i) {
1037         PUSHs (sv_2mortal (newSVpv (lines[i], 0)));
1038         free (lines[i]);
1039       }
1040       free (lines);
1041