int
adminServerSetClientLimits(virNetServerPtr srv,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
{
long long int maxClients = -1;
long long int maxClientsUnauth = -1;
virTypedParameterPtr param = NULL;
virCheckFlags(0, -1);
if (virTypedParamsValidate(params, nparams,
VIR_SERVER_CLIENTS_MAX,
VIR_TYPED_PARAM_UINT,
VIR_SERVER_CLIENTS_UNAUTH_MAX,
VIR_TYPED_PARAM_UINT,
NULL) < 0)
return -1;
if ((param = virTypedParamsGet(params, nparams,
VIR_SERVER_CLIENTS_MAX)))
maxClients = param->value.ui;
if ((param = virTypedParamsGet(params, nparams,
VIR_SERVER_CLIENTS_UNAUTH_MAX)))
maxClientsUnauth = param->value.ui;
if (virNetServerSetClientLimits(srv, maxClients,
maxClientsUnauth) < 0)
return -1;
return 0;
}
int
adminServerSetThreadPoolParameters(virNetServerPtr srv,
virTypedParameterPtr params,
int nparams,
unsigned int flags)
{
long long int minWorkers = -1;
long long int maxWorkers = -1;
long long int prioWorkers = -1;
virTypedParameterPtr param = NULL;
virCheckFlags(0, -1);
if (virTypedParamsValidate(params, nparams,
VIR_THREADPOOL_WORKERS_MIN,
VIR_TYPED_PARAM_UINT,
VIR_THREADPOOL_WORKERS_MAX,
VIR_TYPED_PARAM_UINT,
VIR_THREADPOOL_WORKERS_PRIORITY,
VIR_TYPED_PARAM_UINT,
NULL) < 0)
return -1;
if ((param = virTypedParamsGet(params, nparams,
VIR_THREADPOOL_WORKERS_MIN)))
minWorkers = param->value.ui;
if ((param = virTypedParamsGet(params, nparams,
VIR_THREADPOOL_WORKERS_MAX)))
maxWorkers = param->value.ui;
if ((param = virTypedParamsGet(params, nparams,
VIR_THREADPOOL_WORKERS_PRIORITY)))
prioWorkers = param->value.ui;
if (virNetServerSetThreadPoolParameters(srv, minWorkers,
maxWorkers, prioWorkers) < 0)
return -1;
return 0;
}
/**
* virTypedParamsGetString:
* @params: array of typed parameters
* @nparams: number of parameters in the @params array
* @name: name of the parameter to find
* @value: where to store the parameter's value
*
* Finds typed parameter called @name and store its char * value in @value.
* The function does not create a copy of the string and the caller must not
* free the string @value points to. The function fails with
* VIR_ERR_INVALID_ARG error if the parameter does not have the expected type.
* By passing NULL as @value, the function may be used to check presence and
* type of the parameter.
*
* Returns 1 on success, 0 when the parameter does not exist in @params, or
* -1 on error.
*/
int
virTypedParamsGetString(virTypedParameterPtr params,
int nparams,
const char *name,
const char **value)
{
virTypedParameterPtr param;
virResetLastError();
if (!(param = virTypedParamsGet(params, nparams, name)))
return 0;
VIR_TYPED_PARAM_CHECK_TYPE(VIR_TYPED_PARAM_STRING);
if (value)
*value = param->value.s;
return 1;
}
/**
* virTypedParamsGetBoolean:
* @params: array of typed parameters
* @nparams: number of parameters in the @params array
* @name: name of the parameter to find
* @value: where to store the parameter's value
*
* Finds typed parameter called @name and store its boolean value in @value.
* The function fails with VIR_ERR_INVALID_ARG error if the parameter does not
* have the expected type. By passing NULL as @value, the function may be used
* to check presence and type of the parameter.
*
* Returns 1 on success, 0 when the parameter does not exist in @params, or
* -1 on error.
*/
int
virTypedParamsGetBoolean(virTypedParameterPtr params,
int nparams,
const char *name,
int *value)
{
virTypedParameterPtr param;
virResetLastError();
if (!(param = virTypedParamsGet(params, nparams, name)))
return 0;
VIR_TYPED_PARAM_CHECK_TYPE(VIR_TYPED_PARAM_BOOLEAN);
if (value)
*value = !!param->value.b;
return 1;
}
/**
* virTypedParamsGetDouble:
* @params: array of typed parameters
* @nparams: number of parameters in the @params array
* @name: name of the parameter to find
* @value: where to store the parameter's value
*
* Finds typed parameter called @name and store its double value in @value.
* The function fails with VIR_ERR_INVALID_ARG error if the parameter does not
* have the expected type. By passing NULL as @value, the function may be used
* to check presence and type of the parameter.
*
* Returns 1 on success, 0 when the parameter does not exist in @params, or
* -1 on error.
*/
int
virTypedParamsGetDouble(virTypedParameterPtr params,
int nparams,
const char *name,
double *value)
{
virTypedParameterPtr param;
virResetLastError();
if (!(param = virTypedParamsGet(params, nparams, name)))
return 0;
VIR_TYPED_PARAM_CHECK_TYPE(VIR_TYPED_PARAM_DOUBLE);
if (value)
*value = param->value.d;
return 1;
}
/**
* virTypedParamsGetULLong:
* @params: array of typed parameters
* @nparams: number of parameters in the @params array
* @name: name of the parameter to find
* @value: where to store the parameter's value
*
* Finds typed parameter called @name and store its unsigned long long int
* value in @value. The function fails with VIR_ERR_INVALID_ARG error if the
* parameter does not have the expected type. By passing NULL as @value, the
* function may be used to check presence and type of the parameter.
*
* Returns 1 on success, 0 when the parameter does not exist in @params, or
* -1 on error.
*/
int
virTypedParamsGetULLong(virTypedParameterPtr params,
int nparams,
const char *name,
unsigned long long *value)
{
virTypedParameterPtr param;
virResetLastError();
if (!(param = virTypedParamsGet(params, nparams, name)))
return 0;
VIR_TYPED_PARAM_CHECK_TYPE(VIR_TYPED_PARAM_ULLONG);
if (value)
*value = param->value.ul;
return 1;
}
/**
* virTypedParamsGetUInt:
* @params: array of typed parameters
* @nparams: number of parameters in the @params array
* @name: name of the parameter to find
* @value: where to store the parameter's value
*
* Finds typed parameter called @name and store its unsigned int value in
* @value. The function fails with VIR_ERR_INVALID_ARG error if the parameter
* does not have the expected type. By passing NULL as @value, the function
* may be used to check presence and type of the parameter.
*
* Returns 1 on success, 0 when the parameter does not exist in @params, or
* -1 on error.
*/
int
virTypedParamsGetUInt(virTypedParameterPtr params,
int nparams,
const char *name,
unsigned int *value)
{
virTypedParameterPtr param;
virResetLastError();
if (!(param = virTypedParamsGet(params, nparams, name)))
return 0;
VIR_TYPED_PARAM_CHECK_TYPE(VIR_TYPED_PARAM_UINT);
if (value)
*value = param->value.ui;
return 1;
}
/**
* virTypedParamsReplaceString:
* @params: pointer to the array of typed parameters
* @nparams: number of parameters in the @params array
* @name: name of the parameter to set
* @value: the value to store into the parameter
*
* Sets new value @value to parameter called @name with char * type. If the
* parameter does not exist yet in @params, it is automatically created and
* @naprams is incremented by one. Otherwise current value of the parameter
* is freed on success. The function creates its own copy of @value string,
* which needs to be freed using virTypedParamsFree or virTypedParamsClear.
*
* Returns 0 on success, -1 on error.
*/
int
virTypedParamsReplaceString(virTypedParameterPtr *params,
int *nparams,
const char *name,
const char *value)
{
char *str = NULL;
char *old = NULL;
size_t n = *nparams;
virTypedParameterPtr param;
param = virTypedParamsGet(*params, n, name);
if (param) {
if (param->type != VIR_TYPED_PARAM_STRING) {
virReportError(VIR_ERR_INVALID_ARG,
_("Parameter '%s' is not a string"),
param->field);
goto error;
}
old = param->value.s;
} else {
if (VIR_EXPAND_N(*params, n, 1) < 0)
goto error;
param = *params + n - 1;
}
if (VIR_STRDUP(str, value) < 0)
goto error;
if (virTypedParameterAssign(param, name,
VIR_TYPED_PARAM_STRING, str) < 0) {
param->value.s = old;
VIR_FREE(str);
goto error;
}
VIR_FREE(old);
*nparams = n;
return 0;
error:
return -1;
}
