/** * virObjectEventStateNew: * * Allocate a new event state object. */ virObjectEventStatePtr virObjectEventStateNew(void) { virObjectEventStatePtr state = NULL; if (virObjectEventInitialize() < 0) return NULL; if (!(state = virObjectLockableNew(virObjectEventStateClass))) return NULL; if (VIR_ALLOC(state->callbacks) < 0) goto error; if (!(state->queue = virObjectEventQueueNew())) goto error; state->timer = -1; return state; error: virObjectUnref(state); return NULL; }
virPortAllocatorPtr virPortAllocatorNew(const char *name, unsigned short start, unsigned short end) { virPortAllocatorPtr pa; if (start >= end) { virReportInvalidArg(start, "start port %d must be less than end port %d", start, end); return NULL; } if (virPortAllocatorInitialize() < 0) return NULL; if (!(pa = virObjectLockableNew(virPortAllocatorClass))) return NULL; pa->start = start; pa->end = end; if (!(pa->bitmap = virBitmapNew((end-start)+1)) || VIR_STRDUP(pa->name, name) < 0) { virObjectUnref(pa); return NULL; } return pa; }
virKeepAlivePtr virKeepAliveNew(int interval, unsigned int count, void *client, virKeepAliveSendFunc sendCB, virKeepAliveDeadFunc deadCB, virKeepAliveFreeFunc freeCB) { virKeepAlivePtr ka; VIR_DEBUG("client=%p, interval=%d, count=%u", client, interval, count); if (virKeepAliveInitialize() < 0) return NULL; if (!(ka = virObjectLockableNew(virKeepAliveClass))) return NULL; ka->interval = interval; ka->count = count; ka->countToDeath = count; ka->timer = -1; ka->client = client; ka->sendCB = sendCB; ka->deadCB = deadCB; ka->freeCB = freeCB; PROBE(RPC_KEEPALIVE_NEW, "ka=%p client=%p", ka, ka->client); return ka; }
virNetSASLSessionPtr virNetSASLSessionNewServer(virNetSASLContextPtr ctxt ATTRIBUTE_UNUSED, const char *service, const char *localAddr, const char *remoteAddr) { virNetSASLSessionPtr sasl = NULL; int err; if (!(sasl = virObjectLockableNew(virNetSASLSessionClass))) return NULL; /* Arbitrary size for amount of data we can encode in a single block */ sasl->maxbufsize = 1 << 16; err = sasl_server_new(service, NULL, NULL, localAddr, remoteAddr, NULL, SASL_SUCCESS_DATA, &sasl->conn); if (err != SASL_OK) { virReportError(VIR_ERR_AUTH_FAILED, _("Failed to create SASL client context: %d (%s)"), err, sasl_errstring(err, NULL, NULL)); goto cleanup; } return sasl; cleanup: virObjectUnref(sasl); return NULL; }
virNetDaemonPtr virNetDaemonNew(void) { virNetDaemonPtr dmn; struct sigaction sig_action; if (virNetDaemonInitialize() < 0) return NULL; if (!(dmn = virObjectLockableNew(virNetDaemonClass))) return NULL; dmn->sigwrite = dmn->sigread = -1; dmn->privileged = geteuid() == 0; dmn->autoShutdownInhibitFd = -1; if (virEventRegisterDefaultImpl() < 0) goto error; memset(&sig_action, 0, sizeof(sig_action)); sig_action.sa_handler = SIG_IGN; sigaction(SIGPIPE, &sig_action, NULL); return dmn; error: virObjectUnref(dmn); return NULL; }
virDomainCapsPtr virDomainCapsNew(const char *path, const char *machine, virArch arch, virDomainVirtType virttype) { virDomainCapsPtr caps = NULL; if (virDomainCapsInitialize() < 0) return NULL; if (!(caps = virObjectLockableNew(virDomainCapsClass))) return NULL; if (VIR_STRDUP(caps->path, path) < 0 || VIR_STRDUP(caps->machine, machine) < 0) goto error; caps->arch = arch; caps->virttype = virttype; return caps; error: virObjectUnref(caps); return NULL; }
virConnectCloseCallbackDataPtr virNewConnectCloseCallbackData(void) { if (virDataTypesInitialize() < 0) return NULL; return virObjectLockableNew(virConnectCloseCallbackDataClass); }
/** * virGetConnect: * * Allocates a new hypervisor connection object. * * Returns a pointer to the connection object, or NULL on error. */ virConnectPtr virGetConnect(void) { if (virDataTypesInitialize() < 0) return NULL; return virObjectLockableNew(virConnectClass); }
virAdmConnectPtr virAdmConnectNew(void) { virAdmConnectPtr ret; if (virDataTypesInitialize() < 0) return NULL; if (!(ret = virObjectLockableNew(virAdmConnectClass))) return NULL; if (!(ret->closeCallback = virObjectLockableNew(virAdmConnectCloseCallbackDataClass))) goto error; return ret; error: virObjectUnref(ret); return NULL; }
static virNetServerClientPtr virNetServerClientNewInternal(unsigned long long id, virNetSocketPtr sock, int auth, #ifdef WITH_GNUTLS virNetTLSContextPtr tls, #endif bool readonly, size_t nrequests_max, long long timestamp) { virNetServerClientPtr client; if (virNetServerClientInitialize() < 0) return NULL; if (!(client = virObjectLockableNew(virNetServerClientClass))) return NULL; client->id = id; client->sock = virObjectRef(sock); client->auth = auth; client->readonly = readonly; #ifdef WITH_GNUTLS client->tlsCtxt = virObjectRef(tls); #endif client->nrequests_max = nrequests_max; client->conn_time = timestamp; client->sockTimer = virEventAddTimeout(-1, virNetServerClientSockTimerFunc, client, NULL); if (client->sockTimer < 0) goto error; /* Prepare one for packet receive */ if (!(client->rx = virNetMessageNew(true))) goto error; client->rx->bufferLength = VIR_NET_MESSAGE_LEN_MAX; if (VIR_ALLOC_N(client->rx->buffer, client->rx->bufferLength) < 0) goto error; client->nrequests = 1; PROBE(RPC_SERVER_CLIENT_NEW, "client=%p sock=%p", client, client->sock); return client; error: virObjectUnref(client); return NULL; }
virSecretObjPtr virSecretObjNew(void) { virSecretObjPtr secret; if (virSecretObjInitialize() < 0) return NULL; if (!(secret = virObjectLockableNew(virSecretObjClass))) return NULL; return secret; }
virUSBDeviceListPtr virUSBDeviceListNew(void) { virUSBDeviceListPtr list; if (virUSBInitialize() < 0) return NULL; if (!(list = virObjectLockableNew(virUSBDeviceListClass))) return NULL; return list; }
virStoragePoolObjPtr virStoragePoolObjNew(void) { virStoragePoolObjPtr obj; if (virStoragePoolObjInitialize() < 0) return NULL; if (!(obj = virObjectLockableNew(virStoragePoolObjClass))) return NULL; virObjectLock(obj); obj->active = false; return obj; }
static virInterfaceObjPtr virInterfaceObjNew(void) { virInterfaceObjPtr obj; if (virInterfaceObjInitialize() < 0) return NULL; if (!(obj = virObjectLockableNew(virInterfaceObjClass))) return NULL; virObjectLock(obj); return obj; }
static virPortAllocatorPtr virPortAllocatorNew(void) { virPortAllocatorPtr pa; if (!(pa = virObjectLockableNew(virPortAllocatorClass))) return NULL; if (!(pa->bitmap = virBitmapNew(VIR_PORT_ALLOCATOR_NUM_PORTS))) goto error; return pa; error: virObjectUnref(pa); return NULL; }
virDomainObjListPtr virDomainObjListNew(void) { virDomainObjListPtr doms; if (virDomainObjListInitialize() < 0) return NULL; if (!(doms = virObjectLockableNew(virDomainObjListClass))) return NULL; if (!(doms->objs = virHashCreate(50, virObjectFreeHashData)) || !(doms->objsName = virHashCreate(50, virObjectFreeHashData))) { virObjectUnref(doms); return NULL; } return doms; }
virSecretObjListPtr virSecretObjListNew(void) { virSecretObjListPtr secrets; if (virSecretObjInitialize() < 0) return NULL; if (!(secrets = virObjectLockableNew(virSecretObjListClass))) return NULL; if (!(secrets->objs = virHashCreate(50, virObjectFreeHashData))) { virObjectUnref(secrets); return NULL; } return secrets; }
virCloseCallbacksPtr virCloseCallbacksNew(void) { virCloseCallbacksPtr closeCallbacks; if (virCloseCallbacksInitialize() < 0) return NULL; if (!(closeCallbacks = virObjectLockableNew(virCloseCallbacksClass))) return NULL; closeCallbacks->list = virHashCreate(5, virHashValueFree); if (!closeCallbacks->list) { virObjectUnref(closeCallbacks); return NULL; } return closeCallbacks; }
static virSecurityManagerPtr virSecurityManagerNewDriver(virSecurityDriverPtr drv, const char *virtDriver, bool allowDiskFormatProbing, bool defaultConfined, bool requireConfined, bool privileged) { virSecurityManagerPtr mgr; char *privateData; if (virSecurityManagerInitialize() < 0) return NULL; VIR_DEBUG("drv=%p (%s) virtDriver=%s allowDiskFormatProbing=%d " "defaultConfined=%d requireConfined=%d privileged=%d", drv, drv->name, virtDriver, allowDiskFormatProbing, defaultConfined, requireConfined, privileged); if (VIR_ALLOC_N(privateData, drv->privateDataLen) < 0) return NULL; if (!(mgr = virObjectLockableNew(virSecurityManagerClass))) { VIR_FREE(privateData); return NULL; } mgr->drv = drv; mgr->allowDiskFormatProbing = allowDiskFormatProbing; mgr->defaultConfined = defaultConfined; mgr->requireConfined = requireConfined; mgr->privileged = privileged; mgr->virtDriver = virtDriver; mgr->privateData = privateData; if (drv->open(mgr) < 0) { virObjectUnref(mgr); return NULL; } return mgr; }
virNetClientStreamPtr virNetClientStreamNew(virNetClientProgramPtr prog, int proc, unsigned serial) { virNetClientStreamPtr st; if (virNetClientStreamInitialize() < 0) return NULL; if (!(st = virObjectLockableNew(virNetClientStreamClass))) return NULL; st->prog = prog; st->proc = proc; st->serial = serial; virObjectRef(prog); return st; }
virNetSASLContextPtr virNetSASLContextNewClient(void) { virNetSASLContextPtr ctxt; int err; if (virNetSASLContextInitialize() < 0) return NULL; err = sasl_client_init(NULL); if (err != SASL_OK) { virReportError(VIR_ERR_AUTH_FAILED, _("failed to initialize SASL library: %d (%s)"), err, sasl_errstring(err, NULL, NULL)); return NULL; } if (!(ctxt = virObjectLockableNew(virNetSASLContextClass))) return NULL; return ctxt; }
virLogHandlerPtr virLogHandlerNew(bool privileged, virLogHandlerShutdownInhibitor inhibitor, void *opaque) { virLogHandlerPtr handler; if (virLogHandlerInitialize() < 0) goto error; if (!(handler = virObjectLockableNew(virLogHandlerClass))) goto error; handler->privileged = privileged; handler->inhibitor = inhibitor; handler->opaque = opaque; return handler; error: return NULL; }
virNetSASLContextPtr virNetSASLContextNewServer(const char *const*usernameWhitelist) { virNetSASLContextPtr ctxt; int err; if (virNetSASLContextInitialize() < 0) return NULL; err = sasl_server_init(NULL, "libvirt"); if (err != SASL_OK) { virReportError(VIR_ERR_AUTH_FAILED, _("failed to initialize SASL library: %d (%s)"), err, sasl_errstring(err, NULL, NULL)); return NULL; } if (!(ctxt = virObjectLockableNew(virNetSASLContextClass))) return NULL; ctxt->usernameWhitelist = usernameWhitelist; return ctxt; }
static remoteAdminPrivPtr remoteAdminPrivNew(const char *sock_path) { remoteAdminPrivPtr priv = NULL; if (!(priv = virObjectLockableNew(remoteAdminPrivClass))) goto error; if (!(priv->client = virNetClientNewUNIX(sock_path, false, NULL))) goto error; if (!(priv->program = virNetClientProgramNew(ADMIN_PROGRAM, ADMIN_PROTOCOL_VERSION, NULL, 0, NULL))) goto error; if (virNetClientAddProgram(priv->client, priv->program) < 0) goto error; return priv; error: virObjectUnref(priv); return NULL; }
static virSecurityManagerPtr virSecurityManagerNewDriver(virSecurityDriverPtr drv, const char *virtDriver, unsigned int flags) { virSecurityManagerPtr mgr; char *privateData; if (virSecurityManagerInitialize() < 0) return NULL; VIR_DEBUG("drv=%p (%s) virtDriver=%s flags=%x", drv, drv->name, virtDriver, flags); virCheckFlags(VIR_SECURITY_MANAGER_NEW_MASK, NULL); if (VIR_ALLOC_N(privateData, drv->privateDataLen) < 0) return NULL; if (!(mgr = virObjectLockableNew(virSecurityManagerClass))) { VIR_FREE(privateData); return NULL; } mgr->drv = drv; mgr->flags = flags; mgr->virtDriver = virtDriver; mgr->privateData = privateData; if (drv->open(mgr) < 0) { virObjectUnref(mgr); return NULL; } return mgr; }
static void * libxlDomainObjPrivateAlloc(void) { libxlDomainObjPrivatePtr priv; if (libxlDomainObjPrivateInitialize() < 0) return NULL; if (!(priv = virObjectLockableNew(libxlDomainObjPrivateClass))) return NULL; if (!(priv->devs = virChrdevAlloc())) { virObjectUnref(priv); return NULL; } if (libxlDomainObjInitJob(priv) < 0) { virChrdevFree(priv->devs); virObjectUnref(priv); return NULL; } return priv; }
static virNetSocketPtr virNetSocketNew(virSocketAddrPtr localAddr, virSocketAddrPtr remoteAddr, bool isClient, int fd, int errfd, pid_t pid) { virNetSocketPtr sock; int no_slow_start = 1; if (virNetSocketInitialize() < 0) return NULL; VIR_DEBUG("localAddr=%p remoteAddr=%p fd=%d errfd=%d pid=%lld", localAddr, remoteAddr, fd, errfd, (long long) pid); if (virSetCloseExec(fd) < 0) { virReportSystemError(errno, "%s", _("Unable to set close-on-exec flag")); return NULL; } if (virSetNonBlock(fd) < 0) { virReportSystemError(errno, "%s", _("Unable to enable non-blocking flag")); return NULL; } if (!(sock = virObjectLockableNew(virNetSocketClass))) return NULL; if (localAddr) sock->localAddr = *localAddr; if (remoteAddr) sock->remoteAddr = *remoteAddr; sock->fd = fd; sock->errfd = errfd; sock->pid = pid; /* Disable nagle for TCP sockets */ if (sock->localAddr.data.sa.sa_family == AF_INET || sock->localAddr.data.sa.sa_family == AF_INET6) { if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &no_slow_start, sizeof(no_slow_start)) < 0) { virReportSystemError(errno, "%s", _("Unable to disable nagle algorithm")); goto error; } } if (localAddr && !(sock->localAddrStr = virSocketAddrFormatFull(localAddr, true, ";"))) goto error; if (remoteAddr && !(sock->remoteAddrStr = virSocketAddrFormatFull(remoteAddr, true, ";"))) goto error; sock->client = isClient; PROBE(RPC_SOCKET_NEW, "sock=%p fd=%d errfd=%d pid=%lld localAddr=%s, remoteAddr=%s", sock, fd, errfd, (long long) pid, NULLSTR(sock->localAddrStr), NULLSTR(sock->remoteAddrStr)); return sock; error: sock->fd = sock->errfd = -1; /* Caller owns fd/errfd on failure */ virObjectUnref(sock); return NULL; }
qemuAgentPtr qemuAgentOpen(virDomainObjPtr vm, virDomainChrSourceDefPtr config, qemuAgentCallbacksPtr cb) { qemuAgentPtr mon; if (!cb || !cb->eofNotify) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("EOF notify callback must be supplied")); return NULL; } if (qemuAgentInitialize() < 0) return NULL; if (!(mon = virObjectLockableNew(qemuAgentClass))) return NULL; mon->fd = -1; if (virCondInit(&mon->notify) < 0) { virReportSystemError(errno, "%s", _("cannot initialize monitor condition")); virObjectUnref(mon); return NULL; } mon->vm = vm; mon->cb = cb; switch (config->type) { case VIR_DOMAIN_CHR_TYPE_UNIX: mon->fd = qemuAgentOpenUnix(config->data.nix.path, vm->pid, &mon->connectPending); break; case VIR_DOMAIN_CHR_TYPE_PTY: mon->fd = qemuAgentOpenPty(config->data.file.path); break; default: virReportError(VIR_ERR_INTERNAL_ERROR, _("unable to handle monitor type: %s"), virDomainChrTypeToString(config->type)); goto cleanup; } if (mon->fd == -1) goto cleanup; virObjectRef(mon); if ((mon->watch = virEventAddHandle(mon->fd, VIR_EVENT_HANDLE_HANGUP | VIR_EVENT_HANDLE_ERROR | VIR_EVENT_HANDLE_READABLE | (mon->connectPending ? VIR_EVENT_HANDLE_WRITABLE : 0), qemuAgentIO, mon, virObjectFreeCallback)) < 0) { virObjectUnref(mon); virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("unable to register monitor events")); goto cleanup; } VIR_DEBUG("New mon %p fd =%d watch=%d", mon, mon->fd, mon->watch); return mon; cleanup: /* We don't want the 'destroy' callback invoked during * cleanup from construction failure, because that can * give a double-unref on virDomainObjPtr in the caller, * so kill the callbacks now. */ mon->cb = NULL; qemuAgentClose(mon); return NULL; }
virNetServerPtr virNetServerNew(size_t min_workers, size_t max_workers, size_t priority_workers, size_t max_clients, size_t max_anonymous_clients, int keepaliveInterval, unsigned int keepaliveCount, bool keepaliveRequired, const char *mdnsGroupName, virNetServerClientPrivNew clientPrivNew, virNetServerClientPrivPreExecRestart clientPrivPreExecRestart, virFreeCallback clientPrivFree, void *clientPrivOpaque) { virNetServerPtr srv; struct sigaction sig_action; if (virNetServerInitialize() < 0) return NULL; if (!(srv = virObjectLockableNew(virNetServerClass))) return NULL; if (max_workers && !(srv->workers = virThreadPoolNew(min_workers, max_workers, priority_workers, virNetServerHandleJob, srv))) goto error; srv->nclients_max = max_clients; srv->nclients_unauth_max = max_anonymous_clients; srv->keepaliveInterval = keepaliveInterval; srv->keepaliveCount = keepaliveCount; srv->keepaliveRequired = keepaliveRequired; srv->sigwrite = srv->sigread = -1; srv->clientPrivNew = clientPrivNew; srv->clientPrivPreExecRestart = clientPrivPreExecRestart; srv->clientPrivFree = clientPrivFree; srv->clientPrivOpaque = clientPrivOpaque; srv->privileged = geteuid() == 0; srv->autoShutdownInhibitFd = -1; if (VIR_STRDUP(srv->mdnsGroupName, mdnsGroupName) < 0) goto error; if (srv->mdnsGroupName) { if (!(srv->mdns = virNetServerMDNSNew())) goto error; if (!(srv->mdnsGroup = virNetServerMDNSAddGroup(srv->mdns, srv->mdnsGroupName))) goto error; } if (virEventRegisterDefaultImpl() < 0) goto error; memset(&sig_action, 0, sizeof(sig_action)); sig_action.sa_handler = SIG_IGN; sigaction(SIGPIPE, &sig_action, NULL); return srv; error: virObjectUnref(srv); return NULL; }