text: /*
   * libvirt-utils.c: misc helper APIs for python binding
   *
   * Copyright (C) 2013 Red Hat, Inc.
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library.  If not, see
   * <http://www.gnu.org/licenses/>.
   *
   */
  
  #include <errno.h>
  #include <stddef.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <libvirt/libvirt.h>
  #include "libvirt-utils.h"
  
  /**
   * virAlloc:
   * @ptrptr: pointer to pointer for address of allocated memory
   * @size: number of bytes to allocate
   *
   * Allocate  'size' bytes of memory. Return the address of the
   * allocated memory in 'ptrptr'. The newly allocated memory is
   * filled with zeros.
   *
   * Returns -1 on failure to allocate, zero on success
   */
  int virAlloc(void *ptrptr,
               size_t size)
  {
      *(void **)ptrptr = calloc(1, size);
      if (*(void **)ptrptr == NULL) {
          return -1;
      }
      return 0;
  }
  
  /**
   * virAllocN:
   * @ptrptr: pointer to pointer for address of allocated memory
   * @size: number of bytes to allocate
   * @count: number of elements to allocate
   *
   * Allocate an array of memory 'count' elements long,
   * each with 'size' bytes. Return the address of the
   * allocated memory in 'ptrptr'.  The newly allocated
   * memory is filled with zeros.
   *
   * Returns -1 on failure to allocate, zero on success
   */
  int virAllocN(void *ptrptr,
                size_t size,
                size_t count)
  {
      *(void**)ptrptr = calloc(count, size);
      if (*(void**)ptrptr == NULL) {
          return -1;
      }
      return 0;
  }
  
  /**
   * virReallocN:
   * @ptrptr: pointer to pointer for address of allocated memory
   * @size: number of bytes to allocate
   * @count: number of elements in array
   *
   * Resize the block of memory in 'ptrptr' to be an array of
   * 'count' elements, each 'size' bytes in length. Update 'ptrptr'
   * with the address of the newly allocated memory. On failure,
   * 'ptrptr' is not changed and still points to the original memory
   * block. Any newly allocated memory in 'ptrptr' is uninitialized.
   *
   * Returns -1 on failure to allocate, zero on success
   */
  int virReallocN(void *ptrptr,
                  size_t size,
                  size_t count)
  {
      void *tmp;
  
      if (xalloc_oversized(count, size)) {
          errno = ENOMEM;
          return -1;
      }
      tmp = realloc(*(void**)ptrptr, size * count);
      if (!tmp && (size * count)) {
          return -1;
      }
      *(void**)ptrptr = tmp;
      return 0;
  }
  
  
  /**
   * virFree:
   * @ptrptr: pointer to pointer for address of memory to be freed
   *
   * Release the chunk of memory in the pointer pointed to by
   * the 'ptrptr' variable. After release, 'ptrptr' will be
   * updated to point to NULL.
   */
  void virFree(void *ptrptr)
  {
      int save_errno = errno;
  
      free(*(void**)ptrptr);
      *(void**)ptrptr = NULL;
      errno = save_errno;
  }
  
  
  int virFileClose(int *fdptr)
  {
      int saved_errno = 0;
      int rc = 0;
  
      saved_errno = errno;
  
      if (*fdptr < 0)
          return 0;
  
      rc = close(*fdptr);
      *fdptr = -1;
  
      errno = saved_errno;
  
      return rc;
  }
  
  #if ! LIBVIR_CHECK_VERSION(1, 0, 2)
  /**
   * virTypedParamsClear:
   * @params: the array of the typed parameters
   * @nparams: number of parameters in the @params array
   *
   * Frees all memory used by string parameters. The memory occupied by @params
   * is not free; use virTypedParamsFree if you want it to be freed too.
   *
   * Returns nothing.
   */
  void
  virTypedParamsClear(virTypedParameterPtr params,
                      int nparams)
  {
      size_t i;
  
      if (!params)
          return;
  
      for (i = 0; i < nparams; i++) {
          if (params[i].type == VIR_TYPED_PARAM_STRING)
              VIR_FREE(params[i].value.s);
      }
  }
  
  /**
   * virTypedParamsFree:
   * @params: the array of the typed parameters
   * @nparams: number of parameters in the @params array
   *
   * Frees all memory used by string parameters and the memory occuiped by
   * @params.
   *
   * Returns nothing.
   */
  void
  virTypedParamsFree(virTypedParameterPtr params,
                     int nparams)
  {
      virTypedParamsClear(params, nparams);
      VIR_FREE(params);
  }
  #endif /* ! LIBVIR_CHECK_VERSION(1, 0, 2) */
  