/*
	 * URI format: {vpx|esx|gsx}://[<username>@]<hostname>[:<port>]/[<path>][?<query parameter>...]
	 *             <path> = [<folder>/...]<datacenter>/[<folder>/...]<computeresource>[/<hostsystem>]
	 *
	 * If no port is specified the default port is set dependent on the scheme and
	 * transport parameter:
	 * - vpx+http  80
	 * - vpx+https 443
	 * - esx+http  80
	 * - esx+https 443
	 * - gsx+http  8222
	 * - gsx+https 8333
	 *
	 * For a vpx:// connection <path> references a host managed by the vCenter.
	 * In case the host is part of a cluster then <computeresource> is the cluster
	 * name. Otherwise <computeresource> and <hostsystem> are equal and the later
	 * can be omitted. As datacenters and computeresources can be organized in
	 * folders those have to be included in <path>.
	 *
	 * Optional query parameters:
	 * - transport={http|https}
	 * - vcenter={<vcenter>|*}             only useful for an esx:// connection
	 * - no_verify={0|1}
	 * - auto_answer={0|1}
	 * - proxy=[{http|socks|socks4|socks4a|socks5}://]<hostname>[:<port>]
	 *
	 * If no transport parameter is specified https is used.
	 *
	 * The vcenter parameter is only necessary for migration, because the vCenter
	 * server is in charge to initiate a migration between two ESX hosts. The
	 * vcenter parameter can be set to an explicitly hostname or to *. If set to *,
	 * the driver will check if the ESX host is managed by a vCenter and connect to
	 * it. If the ESX host is not managed by a vCenter an error is reported.
	 *
	 * If the no_verify parameter is set to 1, this disables libcurl client checks
	 * of the server's certificate. The default value it 0.
	 *
	 * If the auto_answer parameter is set to 1, the driver will respond to all
	 * virtual machine questions with the default answer, otherwise virtual machine
	 * questions will be reported as errors. The default value it 0.
	 *
	 * The proxy parameter allows to specify a proxy for to be used by libcurl.
	 * The default for the optional <type> part is http and socks is synonymous for
	 * socks5. The optional <port> part allows to override the default port 1080.
	 */
	static virDrvOpenStatus
	esxOpen(virConnectPtr conn, virConnectAuthPtr auth,
	        unsigned int flags)
	{
	    virDrvOpenStatus result = VIR_DRV_OPEN_ERROR;
	    char *plus;
	    esxPrivate *priv = NULL;
	    char *potentialVCenterIpAddress = NULL;
	    char vCenterIpAddress[NI_MAXHOST] = "";
	

	    virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
	
	    /* Decline if the URI is NULL or the scheme is NULL */

	    if (conn->uri == NULL || conn->uri->scheme == NULL) {
	        return VIR_DRV_OPEN_DECLINED;

	    }
	
	    /* Decline if the scheme is not one of {vpx|esx|gsx} */
	    plus = strchr(conn->uri->scheme, '+');
	

	    if (plus == NULL) {

	        if (STRCASENEQ(conn->uri->scheme, "vpx") &&
	            STRCASENEQ(conn->uri->scheme, "esx") &&
	            STRCASENEQ(conn->uri->scheme, "gsx")) {
	            return VIR_DRV_OPEN_DECLINED;

	        }

	    } else {
	        if (plus - conn->uri->scheme != 3 ||
	            (STRCASENEQLEN(conn->uri->scheme, "vpx", 3) &&
	             STRCASENEQLEN(conn->uri->scheme, "esx", 3) &&
	             STRCASENEQLEN(conn->uri->scheme, "gsx", 3))) {
	            return VIR_DRV_OPEN_DECLINED;
	        }
	
	        virReportError(VIR_ERR_INVALID_ARG,
	                       _("Transport '%s' in URI scheme is not supported, try again "
	                         "without the transport part"), plus + 1);
	        return VIR_DRV_OPEN_ERROR;

	    }
	

	    if (STRCASENEQ(conn->uri->scheme, "vpx") &&
	        conn->uri->path != NULL && STRNEQ(conn->uri->path, "/")) {
	        VIR_WARN("Ignoring unexpected path '%s' for non-vpx scheme '%s'",
	                 conn->uri->path, conn->uri->scheme);

	    }
	
	    /* Require server part */

	    if (conn->uri->server == NULL) {
	        virReportError(VIR_ERR_INVALID_ARG, "%s",
	                       _("URI is missing the server part"));
	        return VIR_DRV_OPEN_ERROR;

	    }
	
	    /* Require auth */

	    if (auth == NULL || auth->cb == NULL) {
	        virReportError(VIR_ERR_INVALID_ARG, "%s",
	                       _("Missing or invalid auth pointer"));
	        return VIR_DRV_OPEN_ERROR;

	    }
	
	    /* Allocate per-connection private data */

	    if (VIR_ALLOC(priv) < 0) {
	        virReportOOMError();
	        goto cleanup;

	    }
	

	    if (esxUtil_ParseUri(&priv->parsedUri, conn->uri) < 0) {

	        goto cleanup;
	    }
	
	    priv->maxVcpus = -1;
	    priv->supportsVMotion = esxVI_Boolean_Undefined;
	    priv->supportsLongMode = esxVI_Boolean_Undefined;
	    priv->usedCpuTimeCounterId = -1;
	
	    /*
	     * Set the port dependent on the transport protocol if no port is
	     * specified. This allows us to rely on the port parameter being
	     * correctly set when building URIs later on, without the need to
	     * distinguish between the situations port == 0 and port != 0
	     */
	    if (conn->uri->port == 0) {
	        if (STRCASEEQ(conn->uri->scheme, "vpx") ||
	            STRCASEEQ(conn->uri->scheme, "esx")) {
	            if (STRCASEEQ(priv->parsedUri->transport, "https")) {
	                conn->uri->port = 443;
	            } else {
	                conn->uri->port = 80;
	            }
	        } else { /* GSX */
	            if (STRCASEEQ(priv->parsedUri->transport, "https")) {
	                conn->uri->port = 8333;
	            } else {
	                conn->uri->port = 8222;
	            }
	        }
	    }
	
	    if (STRCASEEQ(conn->uri->scheme, "esx") ||
	        STRCASEEQ(conn->uri->scheme, "gsx")) {
	        /* Connect to host */
	        if (esxConnectToHost(priv, conn, auth,
	                             &potentialVCenterIpAddress) < 0) {
	            goto cleanup;
	        }
	
	        /* Connect to vCenter */
	        if (priv->parsedUri->vCenter != NULL) {
	            if (STREQ(priv->parsedUri->vCenter, "*")) {
	                if (potentialVCenterIpAddress == NULL) {
	                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
	                                   _("This host is not managed by a vCenter"));
	                    goto cleanup;
	                }
	
	                if (virStrcpyStatic(vCenterIpAddress,
	                                    potentialVCenterIpAddress) == NULL) {
	                    virReportError(VIR_ERR_INTERNAL_ERROR,
	                                   _("vCenter IP address %s too big for destination"),
	                                   potentialVCenterIpAddress);
	                    goto cleanup;
	                }
	            } else {
	                if (esxUtil_ResolveHostname(priv->parsedUri->vCenter,
	                                            vCenterIpAddress, NI_MAXHOST) < 0) {
	                    goto cleanup;
	                }
	
	                if (potentialVCenterIpAddress != NULL &&
	                    STRNEQ(vCenterIpAddress, potentialVCenterIpAddress)) {
	                    virReportError(VIR_ERR_INTERNAL_ERROR,
	                                   _("This host is managed by a vCenter with IP "
	                                     "address %s, but a mismachting vCenter '%s' "
	                                     "(%s) has been specified"),
	                                   potentialVCenterIpAddress, priv->parsedUri->vCenter,
	                                   vCenterIpAddress);
	                    goto cleanup;
	                }
	            }
	
	            if (esxConnectToVCenter(priv, conn, auth,
	                                    vCenterIpAddress,
	                                    priv->host->ipAddress) < 0) {
	                goto cleanup;
	            }
	        }
	
	        priv->primary = priv->host;
	    } else { /* VPX */
	        /* Connect to vCenter */
	        if (esxConnectToVCenter(priv, conn, auth,
	                                conn->uri->server,
	                                NULL) < 0) {
	            goto cleanup;
	        }
	
	        priv->primary = priv->vCenter;
	    }
	
	    /* Setup capabilities */
	    priv->caps = esxCapsInit(priv);
	
	    if (priv->caps == NULL) {
	        goto cleanup;
	    }
	
	    conn->privateData = priv;
	    priv = NULL;
	    result = VIR_DRV_OPEN_SUCCESS;
	

	  cleanup:
	    esxFreePrivate(&priv);

	    VIR_FREE(potentialVCenterIpAddress);
	

	    return result;
	}