bool virNetServerClientGetReadonly(virNetServerClientPtr client) { bool readonly; virNetServerClientLock(client); readonly = client->readonly; virNetServerClientUnlock(client); return readonly; }
void *virNetServerClientGetPrivateData(virNetServerClientPtr client) { void *data; virNetServerClientLock(client); data = client->privateData; virNetServerClientUnlock(client); return data; }
bool virNetServerClientWantClose(virNetServerClientPtr client) { bool wantClose; virNetServerClientLock(client); wantClose = client->wantClose; virNetServerClientUnlock(client); return wantClose; }
bool virNetServerClientIsClosed(virNetServerClientPtr client) { bool closed; virNetServerClientLock(client); closed = client->sock == NULL ? true : false; virNetServerClientUnlock(client); return closed; }
int virNetServerClientGetAuth(virNetServerClientPtr client) { int auth; virNetServerClientLock(client); auth = client->auth; virNetServerClientUnlock(client); return auth; }
bool virNetServerClientHasTLSSession(virNetServerClientPtr client) { bool has; virNetServerClientLock(client); has = client->tls ? true : false; virNetServerClientUnlock(client); return has; }
int virNetServerClientStartKeepAlive(virNetServerClientPtr client) { int ret; virNetServerClientLock(client); ret = virKeepAliveStart(client->keepalive, 0, 0); virNetServerClientUnlock(client); return ret; }
bool virNetServerClientNeedAuth(virNetServerClientPtr client) { bool need = false; virNetServerClientLock(client); if (client->auth && !client->identity) need = true; virNetServerClientUnlock(client); return need; }
int virNetServerClientGetTLSKeySize(virNetServerClientPtr client) { int size = 0; virNetServerClientLock(client); if (client->tls) size = virNetTLSSessionGetKeySize(client->tls); virNetServerClientUnlock(client); return size; }
int virNetServerClientGetFD(virNetServerClientPtr client) { int fd = -1; virNetServerClientLock(client); if (client->sock) fd = virNetSocketGetFD(client->sock); virNetServerClientUnlock(client); return fd; }
void virNetServerClientSetDispatcher(virNetServerClientPtr client, virNetServerClientDispatchFunc func, void *opaque) { virNetServerClientLock(client); client->dispatchFunc = func; client->dispatchOpaque = opaque; virNetServerClientUnlock(client); }
int virNetServerClientGetUNIXIdentity(virNetServerClientPtr client, uid_t *uid, gid_t *gid, pid_t *pid) { int ret = -1; virNetServerClientLock(client); if (client->sock) ret = virNetSocketGetUNIXIdentity(client->sock, uid, gid, pid); virNetServerClientUnlock(client); return ret; }
int virNetServerClientSendMessage(virNetServerClientPtr client, virNetMessagePtr msg) { int ret; virNetServerClientLock(client); ret = virNetServerClientSendMessageLocked(client, msg); virNetServerClientUnlock(client); return ret; }
void virNetServerClientSetSASLSession(virNetServerClientPtr client, virNetSASLSessionPtr sasl) { /* We don't set the sasl session on the socket here * because we need to send out the auth confirmation * in the clear. Only once we complete the next 'tx' * operation do we switch to SASL mode */ virNetServerClientLock(client); client->sasl = virObjectRef(sasl); virNetServerClientUnlock(client); }
static void virNetServerClientSockTimerFunc(int timer, void *opaque) { virNetServerClientPtr client = opaque; virNetServerClientLock(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); }
int virNetServerClientSetIdentity(virNetServerClientPtr client, const char *identity) { int ret = -1; virNetServerClientLock(client); if (!(client->identity = strdup(identity))) { virReportOOMError(); goto error; } ret = 0; error: virNetServerClientUnlock(client); return ret; }
bool virNetServerClientIsSecure(virNetServerClientPtr client) { bool secure = false; virNetServerClientLock(client); if (client->tls) secure = true; #if HAVE_SASL if (client->sasl) secure = true; #endif if (client->sock && virNetSocketIsLocal(client->sock)) secure = true; virNetServerClientUnlock(client); return secure; }
int virNetServerClientInit(virNetServerClientPtr client) { virNetServerClientLock(client); if (!client->tlsCtxt) { /* Plain socket, so prepare to read first message */ if (virNetServerClientRegisterEvent(client) < 0) goto error; } else { int ret; if (!(client->tls = virNetTLSSessionNew(client->tlsCtxt, NULL))) goto error; virNetSocketSetTLSSession(client->sock, client->tls); /* Begin the TLS handshake. */ ret = virNetTLSSessionHandshake(client->tls); if (ret == 0) { /* Unlikely, but ... Next step is to check the certificate. */ if (virNetServerClientCheckAccess(client) < 0) goto error; /* Handshake & cert check OK, so prepare to read first message */ if (virNetServerClientRegisterEvent(client) < 0) goto error; } else if (ret > 0) { /* Most likely, need to do more handshake data */ if (virNetServerClientRegisterEvent(client) < 0) goto error; } else { goto error; } } virNetServerClientUnlock(client); return 0; error: client->wantClose = true; virNetServerClientUnlock(client); return -1; }
static void virNetServerClientDispatchEvent(virNetSocketPtr sock, int events, void *opaque) { virNetServerClientPtr client = opaque; virNetServerClientLock(client); if (client->sock != sock) { virNetSocketRemoveIOCallback(sock); virNetServerClientUnlock(client); return; } if (events & (VIR_EVENT_HANDLE_WRITABLE | VIR_EVENT_HANDLE_READABLE)) { if (client->tls && virNetTLSSessionGetHandshakeStatus(client->tls) != VIR_NET_TLS_HANDSHAKE_COMPLETE) { virNetServerClientDispatchHandshake(client); } else { if (events & VIR_EVENT_HANDLE_WRITABLE) virNetServerClientDispatchWrite(client); if (events & VIR_EVENT_HANDLE_READABLE && client->rx) virNetServerClientDispatchRead(client); } } /* NB, will get HANGUP + READABLE at same time upon * disconnect */ if (events & (VIR_EVENT_HANDLE_ERROR | VIR_EVENT_HANDLE_HANGUP)) client->wantClose = true; virNetServerClientUnlock(client); }
void virNetServerClientImmediateClose(virNetServerClientPtr client) { virNetServerClientLock(client); client->wantClose = true; virNetServerClientUnlock(client); }
void virNetServerClientDelayedClose(virNetServerClientPtr client) { virNetServerClientLock(client); client->delayedClose = true; virNetServerClientUnlock(client); }
/* * * We don't free stuff here, merely disconnect the client's * network socket & resources. * * Full free of the client is done later in a safe point * where it can be guaranteed it is no longer in use */ void virNetServerClientClose(virNetServerClientPtr client) { virNetServerClientCloseFunc cf; virKeepAlivePtr ka; virNetServerClientLock(client); VIR_DEBUG("client=%p", client); if (!client->sock) { virNetServerClientUnlock(client); return; } if (client->keepalive) { virKeepAliveStop(client->keepalive); ka = client->keepalive; client->keepalive = NULL; virObjectRef(client); virNetServerClientUnlock(client); virObjectUnref(ka); virNetServerClientLock(client); virObjectUnref(client); } if (client->privateDataCloseFunc) { cf = client->privateDataCloseFunc; virObjectRef(client); virNetServerClientUnlock(client); (cf)(client); virNetServerClientLock(client); virObjectUnref(client); } /* Do now, even though we don't close the socket * until end, to ensure we don't get invoked * again due to tls shutdown */ if (client->sock) virNetSocketRemoveIOCallback(client->sock); if (client->tls) { virObjectUnref(client->tls); client->tls = NULL; } client->wantClose = true; while (client->rx) { virNetMessagePtr msg = virNetMessageQueueServe(&client->rx); virNetMessageFree(msg); } while (client->tx) { virNetMessagePtr msg = virNetMessageQueueServe(&client->tx); virNetMessageFree(msg); } if (client->sock) { virObjectUnref(client->sock); client->sock = NULL; } virNetServerClientUnlock(client); }