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);
}
