#define VIR_FROM_THIS VIR_FROM_RPC
struct _virKeepAlive {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
int interval;
unsigned int count;
static int virKeepAliveOnceInit(void)
{
- if (!(virKeepAliveClass = virClassNew(virClassForObject(),
+ if (!(virKeepAliveClass = virClassNew(virClassForObjectLockable(),
"virKeepAlive",
sizeof(virKeepAlive),
virKeepAliveDispose)))
VIR_ONCE_GLOBAL_INIT(virKeepAlive)
-static void
-virKeepAliveLock(virKeepAlivePtr ka)
-{
- virMutexLock(&ka->lock);
-}
-
-static void
-virKeepAliveUnlock(virKeepAlivePtr ka)
-{
- virMutexUnlock(&ka->lock);
-}
-
-
static virNetMessagePtr
virKeepAliveMessage(virKeepAlivePtr ka, int proc)
{
bool dead;
void *client;
- virKeepAliveLock(ka);
+ virObjectLock(ka);
client = ka->client;
dead = virKeepAliveTimerInternal(ka, &msg);
goto cleanup;
virObjectRef(ka);
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
if (dead) {
ka->deadCB(client);
virNetMessageFree(msg);
}
- virKeepAliveLock(ka);
+ virObjectLock(ka);
virObjectUnref(ka);
cleanup:
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
}
if (virKeepAliveInitialize() < 0)
return NULL;
- if (!(ka = virObjectNew(virKeepAliveClass)))
+ if (!(ka = virObjectLockableNew(virKeepAliveClass)))
return NULL;
- if (virMutexInit(&ka->lock) < 0) {
- VIR_FREE(ka);
- return NULL;
- }
-
ka->interval = interval;
ka->count = count;
ka->countToDeath = count;
{
virKeepAlivePtr ka = obj;
- virMutexDestroy(&ka->lock);
ka->freeCB(ka->client);
}
int timeout;
time_t now;
- virKeepAliveLock(ka);
+ virObjectLock(ka);
if (ka->timer >= 0) {
VIR_DEBUG("Keepalive messages already enabled");
ret = 0;
cleanup:
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
return ret;
}
void
virKeepAliveStop(virKeepAlivePtr ka)
{
- virKeepAliveLock(ka);
+ virObjectLock(ka);
PROBE(RPC_KEEPALIVE_STOP,
"ka=%p client=%p",
ka->timer = -1;
}
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
}
if (!ka)
return -1;
- virKeepAliveLock(ka);
+ virObjectLock(ka);
if (ka->interval <= 0 || ka->intervalStart == 0) {
timeout = -1;
timeout = 0;
}
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
if (timeout < 0)
return -1;
if (!ka)
return false;
- virKeepAliveLock(ka);
+ virObjectLock(ka);
dead = virKeepAliveTimerInternal(ka, msg);
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
return dead;
}
if (!ka)
return false;
- virKeepAliveLock(ka);
+ virObjectLock(ka);
ka->countToDeath = ka->count;
ka->lastPacketReceived = ka->intervalStart = time(NULL);
if (ka->timer >= 0)
virEventUpdateTimeout(ka->timer, ka->interval * 1000);
- virKeepAliveUnlock(ka);
+ virObjectUnlock(ka);
return ret;
}
struct _virNetClient {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
virNetSocketPtr sock;
bool asyncIO;
int reason);
-static void virNetClientLock(virNetClientPtr client)
-{
- virMutexLock(&client->lock);
-}
-
-
-static void virNetClientUnlock(virNetClientPtr client)
-{
- virMutexUnlock(&client->lock);
-}
-
-
void virNetClientSetCloseCallback(virNetClientPtr client,
virNetClientCloseFunc cb,
void *opaque,
virFreeCallback ff)
{
- virNetClientLock(client);
+ virObjectLock(client);
client->closeCb = cb;
client->closeOpaque = opaque;
client->closeFf = ff;
- virNetClientUnlock(client);
+ virObjectUnlock(client);
}
{
bool supported;
- virNetClientLock(client);
+ virObjectLock(client);
supported = !!client->keepalive;
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return supported;
}
{
int ret;
- virNetClientLock(client);
+ virObjectLock(client);
ret = virKeepAliveStart(client->keepalive, interval, count);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
void
virNetClientKeepAliveStop(virNetClientPtr client)
{
- virNetClientLock(client);
+ virObjectLock(client);
virKeepAliveStop(client->keepalive);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
}
static void
goto error;
}
- if (!(client = virObjectNew(virNetClientClass)))
+ if (!(client = virObjectLockableNew(virNetClientClass)))
goto error;
- if (virMutexInit(&client->lock) < 0) {
- VIR_FREE(client);
- goto error;
- }
-
client->sock = sock;
client->wakeupReadFD = wakeupFD[0];
client->wakeupSendFD = wakeupFD[1];
int virNetClientGetFD(virNetClientPtr client)
{
int fd;
- virNetClientLock(client);
+ virObjectLock(client);
fd = virNetSocketGetFD(client->sock);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return fd;
}
int virNetClientDupFD(virNetClientPtr client, bool cloexec)
{
int fd;
- virNetClientLock(client);
+ virObjectLock(client);
fd = virNetSocketDupFD(client->sock, cloexec);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return fd;
}
bool virNetClientHasPassFD(virNetClientPtr client)
{
bool hasPassFD;
- virNetClientLock(client);
+ virObjectLock(client);
hasPassFD = virNetSocketHasPassFD(client->sock);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return hasPassFD;
}
virNetMessageClear(&client->msg);
- virNetClientUnlock(client);
- virMutexDestroy(&client->lock);
+ virObjectUnlock(client);
}
void *closeOpaque = client->closeOpaque;
int closeReason = client->closeReason;
virObjectRef(client);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
if (ka) {
virKeepAliveStop(ka);
if (closeCb)
closeCb(client, closeReason, closeOpaque);
- virNetClientLock(client);
+ virObjectLock(client);
virObjectUnref(client);
}
}
client->wantClose)
return;
- virNetClientLock(client);
+ virObjectLock(client);
virNetClientMarkClose(client, reason);
virNetClientIOEventLoopPassTheBuck(client, NULL);
}
- virNetClientUnlock(client);
+ virObjectUnlock(client);
}
void virNetClientSetSASLSession(virNetClientPtr client,
virNetSASLSessionPtr sasl)
{
- virNetClientLock(client);
+ virObjectLock(client);
client->sasl = virObjectRef(sasl);
virNetSocketSetSASLSession(client->sock, client->sasl);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
}
#endif
# endif
sigaddset(&blockedsigs, SIGPIPE);
- virNetClientLock(client);
+ virObjectLock(client);
if (!(client->tls = virNetTLSSessionNew(tls,
client->hostname)))
goto error;
}
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return 0;
error:
virObjectUnref(client->tls);
client->tls = NULL;
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return -1;
}
#endif
bool virNetClientIsEncrypted(virNetClientPtr client)
{
bool ret = false;
- virNetClientLock(client);
+ virObjectLock(client);
#if WITH_GNUTLS
if (client->tls)
ret = true;
if (client->sasl)
ret = true;
#endif
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
if (!client)
return false;
- virNetClientLock(client);
+ virObjectLock(client);
ret = client->sock && !client->wantClose;
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
int virNetClientAddProgram(virNetClientPtr client,
virNetClientProgramPtr prog)
{
- virNetClientLock(client);
+ virObjectLock(client);
if (VIR_EXPAND_N(client->programs, client->nprograms, 1) < 0)
goto no_memory;
client->programs[client->nprograms-1] = virObjectRef(prog);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return 0;
no_memory:
virReportOOMError();
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return -1;
}
int virNetClientAddStream(virNetClientPtr client,
virNetClientStreamPtr st)
{
- virNetClientLock(client);
+ virObjectLock(client);
if (VIR_EXPAND_N(client->streams, client->nstreams, 1) < 0)
goto no_memory;
client->streams[client->nstreams-1] = virObjectRef(st);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return 0;
no_memory:
virReportOOMError();
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return -1;
}
void virNetClientRemoveStream(virNetClientPtr client,
virNetClientStreamPtr st)
{
- virNetClientLock(client);
+ virObjectLock(client);
size_t i;
for (i = 0 ; i < client->nstreams ; i++) {
if (client->streams[i] == st)
virObjectUnref(st);
cleanup:
- virNetClientUnlock(client);
+ virObjectUnlock(client);
}
int virNetClientGetTLSKeySize(virNetClientPtr client)
{
int ret = 0;
- virNetClientLock(client);
+ virObjectLock(client);
if (client->tls)
ret = virNetTLSSessionGetKeySize(client->tls);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
#endif
/* Release lock while poll'ing so other threads
* can stuff themselves on the queue */
- virNetClientUnlock(client);
+ virObjectUnlock(client);
/* Block SIGWINCH from interrupting poll in curses programs,
* then restore the original signal mask again immediately
ignore_value(pthread_sigmask(SIG_SETMASK, &oldmask, NULL));
- virNetClientLock(client);
+ virObjectLock(client);
if (ret < 0) {
virReportSystemError(errno,
VIR_DEBUG("Going to sleep head=%p call=%p",
client->waitDispatch, thiscall);
/* Go to sleep while other thread is working... */
- if (virCondWait(&thiscall->cond, &client->lock) < 0) {
+ if (virCondWait(&thiscall->cond, &client->parent.lock) < 0) {
virNetClientCallRemove(&client->waitDispatch, thiscall);
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("failed to wait on condition"));
{
virNetClientPtr client = opaque;
- virNetClientLock(client);
+ virObjectLock(client);
VIR_DEBUG("client=%p wantclose=%d", client, client ? client->wantClose : false);
done:
if (client->wantClose)
virNetClientCloseLocked(client);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
}
virNetMessagePtr msg)
{
int ret;
- virNetClientLock(client);
+ virObjectLock(client);
ret = virNetClientSendInternal(client, msg, true, false);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
if (ret < 0)
return -1;
return 0;
virNetMessagePtr msg)
{
int ret;
- virNetClientLock(client);
+ virObjectLock(client);
ret = virNetClientSendInternal(client, msg, false, false);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
if (ret < 0)
return -1;
return 0;
virNetMessagePtr msg)
{
int ret;
- virNetClientLock(client);
+ virObjectLock(client);
ret = virNetClientSendInternal(client, msg, false, true);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
virNetClientStreamPtr st)
{
int ret;
- virNetClientLock(client);
+ virObjectLock(client);
/* Other thread might have already received
* stream EOF so we don't want sent anything.
* Server won't respond anyway.
*/
if (virNetClientStreamEOF(st)) {
- virNetClientUnlock(client);
+ virObjectUnlock(client);
return 0;
}
ret = virNetClientSendInternal(client, msg, true, false);
- virNetClientUnlock(client);
+ virObjectUnlock(client);
if (ret < 0)
return -1;
return 0;
#define VIR_FROM_THIS VIR_FROM_RPC
struct _virNetClientStream {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
virNetClientProgramPtr prog;
int proc;
static int virNetClientStreamOnceInit(void)
{
- if (!(virNetClientStreamClass = virClassNew(virClassForObject(),
+ if (!(virNetClientStreamClass = virClassNew(virClassForObjectLockable(),
"virNetClientStream",
sizeof(virNetClientStream),
virNetClientStreamDispose)))
virNetClientStreamPtr st = opaque;
int events = 0;
-
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (st->cb &&
(st->cbEvents & VIR_STREAM_EVENT_READABLE) &&
virFreeCallback cbFree = st->cbFree;
st->cbDispatch = 1;
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
(cb)(st, events, cbOpaque);
- virMutexLock(&st->lock);
+ virObjectLock(st);
st->cbDispatch = 0;
if (!st->cb && cbFree)
(cbFree)(cbOpaque);
}
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
}
if (virNetClientStreamInitialize() < 0)
return NULL;
- if (!(st = virObjectNew(virNetClientStreamClass)))
+ if (!(st = virObjectLockableNew(virNetClientStreamClass)))
return NULL;
st->prog = prog;
st->proc = proc;
st->serial = serial;
- if (virMutexInit(&st->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("cannot initialize mutex"));
- VIR_FREE(st);
- return NULL;
- }
-
virObjectRef(prog);
return st;
virResetError(&st->err);
VIR_FREE(st->incoming);
- virMutexDestroy(&st->lock);
virObjectUnref(st->prog);
}
virNetMessagePtr msg)
{
bool match = false;
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (virNetClientProgramMatches(st->prog, msg) &&
st->proc == msg->header.proc &&
st->serial == msg->header.serial)
match = true;
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return match;
}
bool virNetClientStreamRaiseError(virNetClientStreamPtr st)
{
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (st->err.code == VIR_ERR_OK) {
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return false;
}
st->err.int1,
st->err.int2,
"%s", st->err.message ? st->err.message : _("Unknown error"));
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return true;
}
virNetMessageError err;
int ret = -1;
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (st->err.code != VIR_ERR_OK)
VIR_DEBUG("Overwriting existing stream error %s", NULLSTR(st->err.message));
cleanup:
xdr_free((xdrproc_t)xdr_virNetMessageError, (void*)&err);
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return ret;
}
int ret = -1;
size_t need;
- virMutexLock(&st->lock);
+ virObjectLock(st);
need = msg->bufferLength - msg->bufferOffset;
if (need) {
size_t avail = st->incomingLength - st->incomingOffset;
ret = 0;
cleanup:
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return ret;
}
if (!(msg = virNetMessageNew(false)))
return -1;
- virMutexLock(&st->lock);
+ virObjectLock(st);
msg->header.prog = virNetClientProgramGetProgram(st->prog);
msg->header.vers = virNetClientProgramGetVersion(st->prog);
msg->header.serial = st->serial;
msg->header.proc = st->proc;
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
if (virNetMessageEncodeHeader(msg) < 0)
goto error;
int rv = -1;
VIR_DEBUG("st=%p client=%p data=%p nbytes=%zu nonblock=%d",
st, client, data, nbytes, nonblock);
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (!st->incomingOffset && !st->incomingEOF) {
virNetMessagePtr msg;
int ret;
msg->header.status = VIR_NET_CONTINUE;
VIR_DEBUG("Dummy packet to wait for stream data");
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
ret = virNetClientSendWithReplyStream(client, msg, st);
- virMutexLock(&st->lock);
+ virObjectLock(st);
virNetMessageFree(msg);
if (ret < 0)
virNetClientStreamEventTimerUpdate(st);
cleanup:
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return rv;
}
{
int ret = -1;
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (st->cb) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("multiple stream callbacks not supported"));
ret = 0;
cleanup:
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return ret;
}
{
int ret = -1;
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (!st->cb) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("no stream callback registered"));
ret = 0;
cleanup:
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return ret;
}
{
int ret = -1;
- virMutexLock(&st->lock);
+ virObjectLock(st);
if (!st->cb) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"%s", _("no stream callback registered"));
ret = 0;
cleanup:
- virMutexUnlock(&st->lock);
+ virObjectUnlock(st);
return ret;
}
#define VIR_FROM_THIS VIR_FROM_RPC
struct _virNetSASLContext {
- virObject object;
+ virObjectLockable parent;
- virMutex lock;
const char *const*usernameWhitelist;
};
struct _virNetSASLSession {
- virObject object;
+ virObjectLockable parent;
- virMutex lock;
sasl_conn_t *conn;
size_t maxbufsize;
};
static virClassPtr virNetSASLContextClass;
static virClassPtr virNetSASLSessionClass;
-static void virNetSASLContextDispose(void *obj);
static void virNetSASLSessionDispose(void *obj);
static int virNetSASLContextOnceInit(void)
{
- if (!(virNetSASLContextClass = virClassNew(virClassForObject(),
+ if (!(virNetSASLContextClass = virClassNew(virClassForObjectLockable(),
"virNetSASLContext",
sizeof(virNetSASLContext),
- virNetSASLContextDispose)))
+ NULL)))
return -1;
- if (!(virNetSASLSessionClass = virClassNew(virClassForObject(),
+ if (!(virNetSASLSessionClass = virClassNew(virClassForObjectLockable(),
"virNetSASLSession",
sizeof(virNetSASLSession),
virNetSASLSessionDispose)))
return NULL;
}
- if (!(ctxt = virObjectNew(virNetSASLContextClass)))
+ if (!(ctxt = virObjectLockableNew(virNetSASLContextClass)))
return NULL;
- if (virMutexInit(&ctxt->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to initialized mutex"));
- VIR_FREE(ctxt);
- return NULL;
- }
-
return ctxt;
}
return NULL;
}
- if (!(ctxt = virObjectNew(virNetSASLContextClass)))
- return NULL;
-
- if (virMutexInit(&ctxt->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to initialized mutex"));
- VIR_FREE(ctxt);
+ if (!(ctxt = virObjectLockableNew(virNetSASLContextClass)))
return NULL;
- }
ctxt->usernameWhitelist = usernameWhitelist;
const char *const*wildcards;
int ret = -1;
- virMutexLock(&ctxt->lock);
+ virObjectLock(ctxt);
/* If the list is not set, allow any DN. */
wildcards = ctxt->usernameWhitelist;
ret = 0;
cleanup:
- virMutexUnlock(&ctxt->lock);
+ virObjectUnlock(ctxt);
return ret;
}
-void virNetSASLContextDispose(void *obj)
-{
- virNetSASLContextPtr ctxt = obj;
-
- virMutexDestroy(&ctxt->lock);
-}
-
virNetSASLSessionPtr virNetSASLSessionNewClient(virNetSASLContextPtr ctxt ATTRIBUTE_UNUSED,
const char *service,
const char *hostname,
virNetSASLSessionPtr sasl = NULL;
int err;
- if (!(sasl = virObjectNew(virNetSASLSessionClass)))
- return NULL;
-
- if (virMutexInit(&sasl->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to initialized mutex"));
- VIR_FREE(sasl);
+ if (!(sasl = virObjectLockableNew(virNetSASLSessionClass)))
return NULL;
- }
/* Arbitrary size for amount of data we can encode in a single block */
sasl->maxbufsize = 1 << 16;
virNetSASLSessionPtr sasl = NULL;
int err;
- if (!(sasl = virObjectNew(virNetSASLSessionClass)))
- return NULL;
-
- if (virMutexInit(&sasl->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to initialized mutex"));
- VIR_FREE(sasl);
+ if (!(sasl = virObjectLockableNew(virNetSASLSessionClass)))
return NULL;
- }
/* Arbitrary size for amount of data we can encode in a single block */
sasl->maxbufsize = 1 << 16;
{
int err;
int ret = -1;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_setprop(sasl->conn, SASL_SSF_EXTERNAL, &ssf);
if (err != SASL_OK) {
ret = 0;
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
{
const void *val = NULL;
int err;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_getprop(sasl->conn, SASL_USERNAME, &val);
if (err != SASL_OK) {
VIR_DEBUG("SASL client username %s", (const char *)val);
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return (const char*)val;
}
int ssf;
const void *val;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_getprop(sasl->conn, SASL_SSF, &val);
if (err != SASL_OK) {
virReportError(VIR_ERR_AUTH_FAILED,
ssf = *(const int *)val;
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ssf;
}
VIR_DEBUG("minSSF=%d maxSSF=%d allowAnonymous=%d maxbufsize=%zu",
minSSF, maxSSF, allowAnonymous, sasl->maxbufsize);
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
memset(&secprops, 0, sizeof(secprops));
secprops.min_ssf = minSSF;
ret = 0;
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
char *ret = NULL;
int err;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_listmech(sasl->conn,
NULL, /* Don't need to set user */
"", /* Prefix */
}
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
VIR_DEBUG("sasl=%p mechlist=%s prompt_need=%p clientout=%p clientoutlen=%p mech=%p",
sasl, mechlist, prompt_need, clientout, clientoutlen, mech);
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_client_start(sasl->conn,
mechlist,
prompt_need,
}
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
VIR_DEBUG("sasl=%p serverin=%s serverinlen=%zu prompt_need=%p clientout=%p clientoutlen=%p",
sasl, serverin, serverinlen, prompt_need, clientout, clientoutlen);
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_client_step(sasl->conn,
serverin,
inlen,
}
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
int err;
int ret = -1;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_server_start(sasl->conn,
mechname,
clientin,
}
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
int err;
int ret = -1;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
err = sasl_server_step(sasl->conn,
clientin,
inlen,
}
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
size_t virNetSASLSessionGetMaxBufSize(virNetSASLSessionPtr sasl)
{
size_t ret;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
ret = sasl->maxbufsize;
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
int err;
ssize_t ret = -1;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
if (inputLen > sasl->maxbufsize) {
virReportSystemError(EINVAL,
_("SASL data length %zu too long, max %zu"),
ret = 0;
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
int err;
ssize_t ret = -1;
- virMutexLock(&sasl->lock);
+ virObjectLock(sasl);
if (inputLen > sasl->maxbufsize) {
virReportSystemError(EINVAL,
_("SASL data length %zu too long, max %zu"),
ret = 0;
cleanup:
- virMutexUnlock(&sasl->lock);
+ virObjectUnlock(sasl);
return ret;
}
if (sasl->conn)
sasl_dispose(&sasl->conn);
- virMutexDestroy(&sasl->lock);
}
};
struct _virNetServer {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
virThreadPoolPtr workers;
static int virNetServerOnceInit(void)
{
- if (!(virNetServerClass = virClassNew(virClassForObject(),
+ if (!(virNetServerClass = virClassNew(virClassForObjectLockable(),
"virNetServer",
sizeof(virNetServer),
virNetServerDispose)))
VIR_ONCE_GLOBAL_INIT(virNetServer)
-static void virNetServerLock(virNetServerPtr srv)
-{
- virMutexLock(&srv->lock);
-}
-
-static void virNetServerUnlock(virNetServerPtr srv)
-{
- virMutexUnlock(&srv->lock);
-}
-
-
static int virNetServerProcessMsg(virNetServerPtr srv,
virNetServerClientPtr client,
virNetServerProgramPtr prog,
VIR_DEBUG("server=%p client=%p message=%p",
srv, client, msg);
- virNetServerLock(srv);
+ virObjectLock(srv);
for (i = 0 ; i < srv->nprograms ; i++) {
if (virNetServerProgramMatches(srv->programs[i], msg)) {
prog = srv->programs[i];
}
cleanup:
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return ret;
}
static int virNetServerAddClient(virNetServerPtr srv,
virNetServerClientPtr client)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
if (srv->nclients >= srv->nclients_max) {
virReportError(VIR_ERR_RPC,
virNetServerClientInitKeepAlive(client, srv->keepaliveInterval,
srv->keepaliveCount);
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return 0;
error:
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return -1;
}
if (virNetServerInitialize() < 0)
return NULL;
- if (!(srv = virObjectNew(virNetServerClass)))
+ if (!(srv = virObjectLockableNew(virNetServerClass)))
return NULL;
if (max_workers &&
goto error;
}
- if (virMutexInit(&srv->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("cannot initialize mutex"));
- goto error;
- }
-
if (virEventRegisterDefaultImpl() < 0)
goto error;
virJSONValuePtr services;
size_t i;
- virMutexLock(&srv->lock);
+ virObjectLock(srv);
if (!(object = virJSONValueNewObject()))
goto error;
}
}
- virMutexUnlock(&srv->lock);
+ virObjectUnlock(srv);
return object;
error:
virJSONValueFree(object);
- virMutexUnlock(&srv->lock);
+ virObjectUnlock(srv);
return NULL;
}
bool virNetServerIsPrivileged(virNetServerPtr srv)
{
bool priv;
- virNetServerLock(srv);
+ virObjectLock(srv);
priv = srv->privileged;
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return priv;
}
void virNetServerAutoShutdown(virNetServerPtr srv,
unsigned int timeout)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
srv->autoShutdownTimeout = timeout;
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
DBusMessage *reply;
int fd;
- virNetServerLock(srv);
+ virObjectLock(srv);
srv->autoShutdownCallingInhibit = false;
VIR_DEBUG("srv=%p", srv);
dbus_message_unref(reply);
cleanup:
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
void virNetServerAddShutdownInhibition(virNetServerPtr srv)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
srv->autoShutdownInhibitions++;
VIR_DEBUG("srv=%p inhibitions=%zu", srv, srv->autoShutdownInhibitions);
"delay");
#endif
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
void virNetServerRemoveShutdownInhibition(virNetServerPtr srv)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
srv->autoShutdownInhibitions--;
VIR_DEBUG("srv=%p inhibitions=%zu", srv, srv->autoShutdownInhibitions);
if (srv->autoShutdownInhibitions == 0)
VIR_FORCE_CLOSE(srv->autoShutdownInhibitFd);
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
siginfo_t siginfo;
int i;
- virNetServerLock(srv);
+ virObjectLock(srv);
if (saferead(srv->sigread, &siginfo, sizeof(siginfo)) != sizeof(siginfo)) {
virReportSystemError(errno, "%s",
if (siginfo.si_signo == srv->signals[i]->signum) {
virNetServerSignalFunc func = srv->signals[i]->func;
void *funcopaque = srv->signals[i]->opaque;
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
func(srv, &siginfo, funcopaque);
return;
}
_("Unexpected signal received: %d"), siginfo.si_signo);
cleanup:
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
static int virNetServerSignalSetup(virNetServerPtr srv)
virNetServerSignalPtr sigdata;
struct sigaction sig_action;
- virNetServerLock(srv);
+ virObjectLock(srv);
if (virNetServerSignalSetup(srv) < 0)
goto error;
srv->signals[srv->nsignals-1] = sigdata;
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return 0;
no_memory:
virReportOOMError();
error:
VIR_FREE(sigdata);
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return -1;
}
virNetServerServicePtr svc,
const char *mdnsEntryName)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
if (VIR_EXPAND_N(srv->services, srv->nservices, 1) < 0)
goto no_memory;
virNetServerDispatchNewClient,
srv);
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return 0;
no_memory:
virReportOOMError();
error:
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return -1;
}
int virNetServerAddProgram(virNetServerPtr srv,
virNetServerProgramPtr prog)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
if (VIR_EXPAND_N(srv->programs, srv->nprograms, 1) < 0)
goto no_memory;
srv->programs[srv->nprograms-1] = virObjectRef(prog);
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return 0;
no_memory:
virReportOOMError();
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return -1;
}
void *opaque) {
virNetServerPtr srv = opaque;
- virNetServerLock(srv);
+ virObjectLock(srv);
if (!srv->autoShutdownInhibitions) {
VIR_DEBUG("Automatic shutdown triggered");
srv->quit = 1;
}
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
{
int i;
- virNetServerLock(srv);
+ virObjectLock(srv);
for (i = 0 ; i < srv->nservices ; i++)
virNetServerServiceToggle(srv->services[i], enabled);
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
int timerActive = 0;
int i;
- virNetServerLock(srv);
+ virObjectLock(srv);
if (srv->mdns &&
virNetServerMDNSStart(srv->mdns) < 0)
}
}
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
if (virEventRunDefaultImpl() < 0) {
- virNetServerLock(srv);
+ virObjectLock(srv);
VIR_DEBUG("Loop iteration error, exiting");
break;
}
- virNetServerLock(srv);
+ virObjectLock(srv);
reprocess:
for (i = 0 ; i < srv->nclients ; i++) {
}
cleanup:
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
void virNetServerQuit(virNetServerPtr srv)
{
- virNetServerLock(srv);
+ virObjectLock(srv);
VIR_DEBUG("Quit requested %p", srv);
srv->quit = 1;
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
void virNetServerDispose(void *obj)
VIR_FREE(srv->mdnsGroupName);
virNetServerMDNSFree(srv->mdns);
-
- virMutexDestroy(&srv->lock);
}
void virNetServerClose(virNetServerPtr srv)
if (!srv)
return;
- virNetServerLock(srv);
+ virObjectLock(srv);
for (i = 0; i < srv->nservices; i++) {
virNetServerServiceClose(srv->services[i]);
}
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
}
bool virNetServerKeepAliveRequired(virNetServerPtr srv)
{
bool required;
- virNetServerLock(srv);
+ virObjectLock(srv);
required = srv->keepaliveRequired;
- virNetServerUnlock(srv);
+ virObjectUnlock(srv);
return required;
}
struct _virNetServerClient
{
- virObject object;
+ virObjectLockable parent;
bool wantClose;
bool delayedClose;
- virMutex lock;
virNetSocketPtr sock;
int auth;
bool readonly;
static int virNetServerClientOnceInit(void)
{
- if (!(virNetServerClientClass = virClassNew(virClassForObject(),
+ if (!(virNetServerClientClass = virClassNew(virClassForObjectLockable(),
"virNetServerClient",
sizeof(virNetServerClient),
virNetServerClientDispose)))
static int virNetServerClientSendMessageLocked(virNetServerClientPtr client,
virNetMessagePtr msg);
-static void virNetServerClientLock(virNetServerClientPtr client)
-{
- virMutexLock(&client->lock);
-}
-
-static void virNetServerClientUnlock(virNetServerClientPtr client)
-{
- virMutexUnlock(&client->lock);
-}
-
-
/*
* @client: a locked client object
*/
return -1;
}
- virNetServerClientLock(client);
+ virObjectLock(client);
filter->id = client->nextFilterID++;
filter->func = func;
ret = filter->id;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
{
virNetServerClientFilterPtr tmp, prev;
- virNetServerClientLock(client);
+ virObjectLock(client);
prev = NULL;
tmp = client->filters;
tmp = tmp->next;
}
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
void *opaque)
{
virNetServerClientPtr client = opaque;
- virNetServerClientLock(client);
+ virObjectLock(client);
virEventUpdateTimeout(timer, -1);
/* Although client->rx != NULL when this timer is enabled, it might have
* changed since the client was unlocked in the meantime. */
if (client->rx)
virNetServerClientDispatchRead(client);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
if (virNetServerClientInitialize() < 0)
return NULL;
- if (!(client = virObjectNew(virNetServerClientClass)))
+ if (!(client = virObjectLockableNew(virNetServerClientClass)))
return NULL;
- if (virMutexInit(&client->lock) < 0) {
- VIR_FREE(client);
- return NULL;
- }
-
client->sock = virObjectRef(sock);
client->auth = auth;
client->readonly = readonly;
if (!object)
return NULL;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (virJSONValueObjectAppendNumberInt(object, "auth", client->auth) < 0)
goto error;
goto error;
}
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return object;
error:
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
virJSONValueFree(object);
return NULL;
}
int virNetServerClientGetAuth(virNetServerClientPtr client)
{
int auth;
- virNetServerClientLock(client);
+ virObjectLock(client);
auth = client->auth;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return auth;
}
bool virNetServerClientGetReadonly(virNetServerClientPtr client)
{
bool readonly;
- virNetServerClientLock(client);
+ virObjectLock(client);
readonly = client->readonly;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return readonly;
}
bool virNetServerClientHasTLSSession(virNetServerClientPtr client)
{
bool has;
- virNetServerClientLock(client);
+ virObjectLock(client);
has = client->tls ? true : false;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return has;
}
int virNetServerClientGetTLSKeySize(virNetServerClientPtr client)
{
int size = 0;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (client->tls)
size = virNetTLSSessionGetKeySize(client->tls);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return size;
}
#endif
int virNetServerClientGetFD(virNetServerClientPtr client)
{
int fd = -1;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (client->sock)
fd = virNetSocketGetFD(client->sock);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return fd;
}
uid_t *uid, gid_t *gid, pid_t *pid)
{
int ret = -1;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (client->sock)
ret = virNetSocketGetUNIXIdentity(client->sock, uid, gid, pid);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
bool virNetServerClientIsSecure(virNetServerClientPtr client)
{
bool secure = false;
- virNetServerClientLock(client);
+ virObjectLock(client);
#if WITH_GNUTLS
if (client->tls)
secure = true;
#endif
if (client->sock && virNetSocketIsLocal(client->sock))
secure = true;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return secure;
}
* in the clear. Only once we complete the next 'tx'
* operation do we switch to SASL mode
*/
- virNetServerClientLock(client);
+ virObjectLock(client);
client->sasl = virObjectRef(sasl);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
#endif
const char *identity)
{
int ret = -1;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (!(client->identity = strdup(identity))) {
virReportOOMError();
goto error;
ret = 0;
error:
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
const char *virNetServerClientGetIdentity(virNetServerClientPtr client)
{
const char *identity;
- virNetServerClientLock(client);
+ virObjectLock(client);
identity = client->identity;
- virNetServerClientLock(client);
+ virObjectUnlock(client);
return identity;
}
void *virNetServerClientGetPrivateData(virNetServerClientPtr client)
{
void *data;
- virNetServerClientLock(client);
+ virObjectLock(client);
data = client->privateData;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return data;
}
void virNetServerClientSetCloseHook(virNetServerClientPtr client,
virNetServerClientCloseFunc cf)
{
- virNetServerClientLock(client);
+ virObjectLock(client);
client->privateDataCloseFunc = cf;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
virNetServerClientDispatchFunc func,
void *opaque)
{
- virNetServerClientLock(client);
+ virObjectLock(client);
client->dispatchFunc = func;
client->dispatchOpaque = opaque;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
virObjectUnref(client->tlsCtxt);
#endif
virObjectUnref(client->sock);
- virNetServerClientUnlock(client);
- virMutexDestroy(&client->lock);
+ virObjectUnlock(client);
}
virNetServerClientCloseFunc cf;
virKeepAlivePtr ka;
- virNetServerClientLock(client);
+ virObjectLock(client);
VIR_DEBUG("client=%p", client);
if (!client->sock) {
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return;
}
ka = client->keepalive;
client->keepalive = NULL;
virObjectRef(client);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
virObjectUnref(ka);
- virNetServerClientLock(client);
+ virObjectLock(client);
virObjectUnref(client);
}
if (client->privateDataCloseFunc) {
cf = client->privateDataCloseFunc;
virObjectRef(client);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
(cf)(client);
- virNetServerClientLock(client);
+ virObjectLock(client);
virObjectUnref(client);
}
client->sock = NULL;
}
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
bool virNetServerClientIsClosed(virNetServerClientPtr client)
{
bool closed;
- virNetServerClientLock(client);
+ virObjectLock(client);
closed = client->sock == NULL ? true : false;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return closed;
}
void virNetServerClientDelayedClose(virNetServerClientPtr client)
{
- virNetServerClientLock(client);
+ virObjectLock(client);
client->delayedClose = true;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
void virNetServerClientImmediateClose(virNetServerClientPtr client)
{
- virNetServerClientLock(client);
+ virObjectLock(client);
client->wantClose = true;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
bool virNetServerClientWantClose(virNetServerClientPtr client)
{
bool wantClose;
- virNetServerClientLock(client);
+ virObjectLock(client);
wantClose = client->wantClose;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return wantClose;
}
int virNetServerClientInit(virNetServerClientPtr client)
{
- virNetServerClientLock(client);
+ virObjectLock(client);
#if WITH_GNUTLS
if (!client->tlsCtxt) {
}
#endif
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return 0;
error:
client->wantClose = true;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return -1;
}
{
virNetServerClientPtr client = opaque;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (client->sock != sock) {
virNetSocketRemoveIOCallback(sock);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return;
}
VIR_EVENT_HANDLE_HANGUP))
client->wantClose = true;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
}
{
int ret;
- virNetServerClientLock(client);
+ virObjectLock(client);
ret = virNetServerClientSendMessageLocked(client, msg);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
bool virNetServerClientNeedAuth(virNetServerClientPtr client)
{
bool need = false;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (client->auth && !client->identity)
need = true;
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return need;
}
virKeepAlivePtr ka;
int ret = -1;
- virNetServerClientLock(client);
+ virObjectLock(client);
if (!(ka = virKeepAliveNew(interval, count, client,
virNetServerClientKeepAliveSendCB,
ka = NULL;
cleanup:
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
if (ka)
virKeepAliveStop(ka);
virObjectUnref(ka);
virNetServerClientStartKeepAlive(virNetServerClientPtr client)
{
int ret;
- virNetServerClientLock(client);
+ virObjectLock(client);
ret = virKeepAliveStart(client->keepalive, 0, 0);
- virNetServerClientUnlock(client);
+ virObjectUnlock(client);
return ret;
}
struct _virNetSocket {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
int fd;
int watch;
static int virNetSocketOnceInit(void)
{
- if (!(virNetSocketClass = virClassNew(virClassForObject(),
+ if (!(virNetSocketClass = virClassNew(virClassForObjectLockable(),
"virNetSocket",
sizeof(virNetSocket),
virNetSocketDispose)))
return NULL;
}
- if (!(sock = virObjectNew(virNetSocketClass)))
- return NULL;
-
- if (virMutexInit(&sock->lock) < 0) {
- virReportSystemError(errno, "%s",
- _("Unable to initialize mutex"));
- VIR_FREE(sock);
+ if (!(sock = virObjectLockableNew(virNetSocketClass)))
return NULL;
- }
if (localAddr)
sock->localAddr = *localAddr;
{
virJSONValuePtr object = NULL;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
#if WITH_SASL
if (sock->saslSession) {
goto error;
}
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return object;
error:
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
virJSONValueFree(object);
return NULL;
}
VIR_FREE(sock->localAddrStr);
VIR_FREE(sock->remoteAddrStr);
-
- virMutexDestroy(&sock->lock);
}
int virNetSocketGetFD(virNetSocketPtr sock)
{
int fd;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
fd = sock->fd;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return fd;
}
bool virNetSocketIsLocal(virNetSocketPtr sock)
{
bool isLocal = false;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (sock->localAddr.data.sa.sa_family == AF_UNIX)
isLocal = true;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return isLocal;
}
bool virNetSocketHasPassFD(virNetSocketPtr sock)
{
bool hasPassFD = false;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (sock->localAddr.data.sa.sa_family == AF_UNIX)
hasPassFD = true;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return hasPassFD;
}
int virNetSocketGetPort(virNetSocketPtr sock)
{
int port;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
port = virSocketAddrGetPort(&sock->localAddr);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return port;
}
{
struct ucred cr;
socklen_t cr_len = sizeof(cr);
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (getsockopt(sock->fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) < 0) {
virReportSystemError(errno, "%s",
_("Failed to get client socket identity"));
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return -1;
}
*uid = cr.uid;
*gid = cr.gid;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return 0;
}
#elif defined(LOCAL_PEERCRED)
{
struct xucred cr;
socklen_t cr_len = sizeof(cr);
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (getsockopt(sock->fd, SOL_SOCKET, LOCAL_PEERCRED, &cr, &cr_len) < 0) {
virReportSystemError(errno, "%s",
_("Failed to get client socket identity"));
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return -1;
}
*uid = cr.cr_uid;
*gid = cr.cr_gid;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return 0;
}
#else
bool blocking)
{
int ret;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
ret = virSetBlocking(sock->fd, blocking);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return ret;
}
void virNetSocketSetTLSSession(virNetSocketPtr sock,
virNetTLSSessionPtr sess)
{
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
virObjectUnref(sock->tlsSession);
sock->tlsSession = virObjectRef(sess);
virNetTLSSessionSetIOCallbacks(sess,
virNetSocketTLSSessionWrite,
virNetSocketTLSSessionRead,
sock);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
}
#endif
void virNetSocketSetSASLSession(virNetSocketPtr sock,
virNetSASLSessionPtr sess)
{
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
virObjectUnref(sock->saslSession);
sock->saslSession = virObjectRef(sess);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
}
#endif
bool virNetSocketHasCachedData(virNetSocketPtr sock ATTRIBUTE_UNUSED)
{
bool hasCached = false;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
#if WITH_SSH2
if (virNetSSHSessionHasCachedData(sock->sshSession))
if (sock->saslDecoded)
hasCached = true;
#endif
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return hasCached;
}
bool virNetSocketHasPendingData(virNetSocketPtr sock ATTRIBUTE_UNUSED)
{
bool hasPending = false;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
#if WITH_SASL
if (sock->saslEncoded)
hasPending = true;
#endif
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return hasPending;
}
ssize_t virNetSocketRead(virNetSocketPtr sock, char *buf, size_t len)
{
ssize_t ret;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
#if WITH_SASL
if (sock->saslSession)
ret = virNetSocketReadSASL(sock, buf, len);
else
#endif
ret = virNetSocketReadWire(sock, buf, len);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return ret;
}
{
ssize_t ret;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
#if WITH_SASL
if (sock->saslSession)
ret = virNetSocketWriteSASL(sock, buf, len);
else
#endif
ret = virNetSocketWriteWire(sock, buf, len);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return ret;
}
_("Sending file descriptors is not supported on this socket"));
return -1;
}
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
PROBE(RPC_SOCKET_SEND_FD,
"sock=%p fd=%d", sock, fd);
if (sendfd(sock->fd, fd) < 0) {
ret = 1;
cleanup:
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return ret;
}
_("Receiving file descriptors is not supported on this socket"));
return -1;
}
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if ((*fd = recvfd(sock->fd, O_CLOEXEC)) < 0) {
if (errno == EAGAIN)
ret = 1;
cleanup:
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return ret;
}
int virNetSocketListen(virNetSocketPtr sock, int backlog)
{
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (listen(sock->fd, backlog > 0 ? backlog : 30) < 0) {
virReportSystemError(errno, "%s", _("Unable to listen on socket"));
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return -1;
}
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return 0;
}
virSocketAddr remoteAddr;
int ret = -1;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
*clientsock = NULL;
cleanup:
VIR_FORCE_CLOSE(fd);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return ret;
}
virNetSocketIOFunc func;
void *eopaque;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
func = sock->func;
eopaque = sock->opaque;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
if (func)
func(sock, events, eopaque);
virFreeCallback ff;
void *eopaque;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
ff = sock->ff;
eopaque = sock->opaque;
sock->func = NULL;
sock->ff = NULL;
sock->opaque = NULL;
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
if (ff)
ff(eopaque);
int ret = -1;
virObjectRef(sock);
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (sock->watch > 0) {
VIR_DEBUG("Watch already registered on socket %p", sock);
goto cleanup;
ret = 0;
cleanup:
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
if (ret != 0)
virObjectUnref(sock);
return ret;
void virNetSocketUpdateIOCallback(virNetSocketPtr sock,
int events)
{
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (sock->watch <= 0) {
VIR_DEBUG("Watch not registered on socket %p", sock);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return;
}
virEventUpdateHandle(sock->watch, events);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
}
void virNetSocketRemoveIOCallback(virNetSocketPtr sock)
{
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
if (sock->watch <= 0) {
VIR_DEBUG("Watch not registered on socket %p", sock);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
return;
}
virEventRemoveHandle(sock->watch);
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
}
void virNetSocketClose(virNetSocketPtr sock)
if (!sock)
return;
- virMutexLock(&sock->lock);
+ virObjectLock(sock);
VIR_FORCE_CLOSE(sock->fd);
}
#endif
- virMutexUnlock(&sock->lock);
+ virObjectUnlock(sock);
}
};
struct _virNetSSHSession {
- virObject object;
+ virObjectLockable parent;
virNetSSHSessionState state;
- virMutex lock;
/* libssh2 internal stuff */
LIBSSH2_SESSION *session;
static int
virNetSSHSessionOnceInit(void)
{
- if (!(virNetSSHSessionClass = virClassNew(virClassForObject(),
+ if (!(virNetSSHSessionClass = virClassNew(virClassForObjectLockable(),
"virNetSSHSession",
sizeof(virNetSSHSession),
virNetSSHSessionDispose)))
virNetSSHSessionAuthSetCallback(virNetSSHSessionPtr sess,
virConnectAuthPtr auth)
{
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
sess->cred = auth;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return 0;
}
void
virNetSSHSessionAuthReset(virNetSSHSessionPtr sess)
{
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
virNetSSHSessionAuthMethodsFree(sess);
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
}
int
return -1;
}
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (!(user = strdup(username)) ||
!(pass = strdup(password)))
auth->password = pass;
auth->method = VIR_NET_SSH_AUTH_PASSWORD;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return 0;
no_memory:
VIR_FREE(user);
VIR_FREE(pass);
virReportOOMError();
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
return -1;
}
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (!(user = strdup(username)))
goto no_memory;
auth->username = user;
auth->method = VIR_NET_SSH_AUTH_AGENT;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return 0;
no_memory:
VIR_FREE(user);
virReportOOMError();
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
return -1;
}
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (!(user = strdup(username)) ||
!(file = strdup(keyfile)))
auth->filename = file;
auth->method = VIR_NET_SSH_AUTH_PRIVKEY;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return 0;
no_memory:
VIR_FREE(pass);
VIR_FREE(file);
virReportOOMError();
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
return -1;
}
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (!(user = strdup(username)))
goto no_memory;
auth->tries = tries;
auth->method = VIR_NET_SSH_AUTH_KEYBOARD_INTERACTIVE;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return 0;
no_memory:
VIR_FREE(user);
virReportOOMError();
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
const char *command)
{
int ret = 0;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
VIR_FREE(sess->channelCommand);
ret = -1;
}
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
{
char *errmsg;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
sess->port = port;
sess->hostKeyVerify = opt;
}
}
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return 0;
no_memory:
virReportOOMError();
error:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
if (virNetSSHSessionInitialize() < 0)
goto error;
- if (!(sess = virObjectNew(virNetSSHSessionClass)))
+ if (!(sess = virObjectLockableNew(virNetSSHSessionClass)))
goto error;
- /* initialize internal structures */
- if (virMutexInit(&sess->lock) < 0) {
- virReportError(VIR_ERR_SSH, "%s",
- _("Failed to initialize mutex"));
- goto error;
- }
-
/* initialize session data, use the internal data for callbacks
* and stick to default memory management functions */
if (!(sess->session = libssh2_session_init_ex(NULL,
return -1;
}
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
/* check if configuration is valid */
if ((ret = virNetSSHValidateConfig(sess)) < 0)
libssh2_session_set_blocking(sess->session, 0);
sess->state = VIR_NET_SSH_STATE_HANDSHAKE_COMPLETE;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
error:
sess->state = VIR_NET_SSH_STATE_ERROR;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
ssize_t ret = -1;
ssize_t read_n = 0;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (sess->state != VIR_NET_SSH_STATE_HANDSHAKE_COMPLETE) {
if (sess->state == VIR_NET_SSH_STATE_ERROR_REMOTE)
virReportError(VIR_ERR_SSH, "%s",
_("Tried to write socket in error state"));
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
libssh2_channel_get_exit_status(sess->channel));
sess->channelCommandReturnValue = libssh2_channel_get_exit_status(sess->channel);
sess->state = VIR_NET_SSH_STATE_ERROR_REMOTE;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
sess->state = VIR_NET_SSH_STATE_CLOSED;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return -1;
}
success:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return read_n;
error:
sess->state = VIR_NET_SSH_STATE_ERROR;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
{
ssize_t ret;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (sess->state != VIR_NET_SSH_STATE_HANDSHAKE_COMPLETE) {
if (sess->state == VIR_NET_SSH_STATE_ERROR_REMOTE)
}
cleanup:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
if (!sess)
return false;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
ret = sess->bufUsed > 0;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
#define VIR_FROM_THIS VIR_FROM_RPC
struct _virNetTLSContext {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
gnutls_certificate_credentials_t x509cred;
gnutls_dh_params_t dhParams;
};
struct _virNetTLSSession {
- virObject object;
-
- virMutex lock;
+ virObjectLockable parent;
bool handshakeComplete;
static int virNetTLSContextOnceInit(void)
{
- if (!(virNetTLSContextClass = virClassNew(virClassForObject(),
+ if (!(virNetTLSContextClass = virClassNew(virClassForObjectLockable(),
"virNetTLSContext",
sizeof(virNetTLSContext),
virNetTLSContextDispose)))
return -1;
- if (!(virNetTLSSessionClass = virClassNew(virClassForObject(),
+ if (!(virNetTLSSessionClass = virClassNew(virClassForObjectLockable(),
"virNetTLSSession",
sizeof(virNetTLSSession),
virNetTLSSessionDispose)))
if (virNetTLSContextInitialize() < 0)
return NULL;
- if (!(ctxt = virObjectNew(virNetTLSContextClass)))
- return NULL;
-
- if (virMutexInit(&ctxt->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to initialized mutex"));
- VIR_FREE(ctxt);
+ if (!(ctxt = virObjectLockableNew(virNetTLSContextClass)))
return NULL;
- }
if ((gnutlsdebug = getenv("LIBVIRT_GNUTLS_DEBUG")) != NULL) {
int val;
{
int ret = -1;
- virMutexLock(&ctxt->lock);
- virMutexLock(&sess->lock);
+ virObjectLock(ctxt);
+ virObjectLock(sess);
if (virNetTLSContextValidCertificate(ctxt, sess) < 0) {
virErrorPtr err = virGetLastError();
VIR_WARN("Certificate check failed %s", err && err->message ? err->message : "<unknown>");
ret = 0;
cleanup:
- virMutexUnlock(&ctxt->lock);
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(ctxt);
+ virObjectUnlock(sess);
return ret;
}
gnutls_dh_params_deinit(ctxt->dhParams);
gnutls_certificate_free_credentials(ctxt->x509cred);
- virMutexDestroy(&ctxt->lock);
}
VIR_DEBUG("ctxt=%p hostname=%s isServer=%d",
ctxt, NULLSTR(hostname), ctxt->isServer);
- if (!(sess = virObjectNew(virNetTLSSessionClass)))
+ if (!(sess = virObjectLockableNew(virNetTLSSessionClass)))
return NULL;
- if (virMutexInit(&sess->lock) < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
- _("Failed to initialized mutex"));
- VIR_FREE(sess);
- return NULL;
- }
-
if (hostname &&
!(sess->hostname = strdup(hostname))) {
virReportOOMError();
virNetTLSSessionReadFunc readFunc,
void *opaque)
{
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
sess->writeFunc = writeFunc;
sess->readFunc = readFunc;
sess->opaque = opaque;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
}
{
ssize_t ret;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
ret = gnutls_record_send(sess->session, buf, len);
if (ret >= 0)
ret = -1;
cleanup:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
{
ssize_t ret;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
ret = gnutls_record_recv(sess->session, buf, len);
if (ret >= 0)
ret = -1;
cleanup:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
{
int ret;
VIR_DEBUG("sess=%p", sess);
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
ret = gnutls_handshake(sess->session);
VIR_DEBUG("Ret=%d", ret);
if (ret == 0) {
ret = -1;
cleanup:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
virNetTLSSessionGetHandshakeStatus(virNetTLSSessionPtr sess)
{
virNetTLSSessionHandshakeStatus ret;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
if (sess->handshakeComplete)
ret = VIR_NET_TLS_HANDSHAKE_COMPLETE;
else if (gnutls_record_get_direction(sess->session) == 0)
ret = VIR_NET_TLS_HANDSHAKE_RECVING;
else
ret = VIR_NET_TLS_HANDSHAKE_SENDING;
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ret;
}
{
gnutls_cipher_algorithm_t cipher;
int ssf;
- virMutexLock(&sess->lock);
+ virObjectLock(sess);
cipher = gnutls_cipher_get(sess->session);
if (!(ssf = gnutls_cipher_get_key_size(cipher))) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
cleanup:
- virMutexUnlock(&sess->lock);
+ virObjectUnlock(sess);
return ssf;
}
VIR_FREE(sess->hostname);
gnutls_deinit(sess->session);
- virMutexDestroy(&sess->lock);
}
/*
projects / thirdparty / libvirt.git / commitdiff
