mirror of
https://gitlab.com/libvirt/libvirt-python.git
synced 2024-10-26 16:25:10 +03:00
4d083fbf60
virTypedParamsClear() and virTypedParamsFree() were introduced in libvirt 1.0.2. In an effort to keep the code clean bring these two functions to libvirt-python if we're building against a version of libvirt that's older than 1.0.2
187 lines
4.5 KiB
C
187 lines
4.5 KiB
C
/*
|
|
* 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) */
|