// Licensed to the Apache Software Foundation (ASF) under one

// or more contributor license agreements. See the NOTICE file

// distributed with this work for additional information

// regarding copyright ownership. The ASF licenses this file

// to you under the Apache License, Version 2.0 (the

// "License"); you may not use this file except in compliance

// with the License. You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing,

// software distributed under the License is distributed on an

// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

// KIND, either express or implied. See the License for the

// specific language governing permissions and limitations

// under the License.

package com.cloud.api;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InterruptedIOException;

import java.lang.reflect.Field;

import java.lang.reflect.Type;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URLEncoder;

import java.security.SecureRandom;

import java.security.Security;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.EnumSet;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TimeZone;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import javax.inject.Inject;

import javax.naming.ConfigurationException;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import com.cloud.cluster.ManagementServerHostVO;

import com.cloud.cluster.dao.ManagementServerHostDao;

import com.cloud.user.Account;

import com.cloud.user.AccountManager;

import com.cloud.user.AccountManagerImpl;

import com.cloud.user.DomainManager;

import com.cloud.user.User;

import com.cloud.user.UserAccount;

import com.cloud.user.UserVO;

import org.apache.cloudstack.acl.APIChecker;

import org.apache.cloudstack.api.APICommand;

import org.apache.cloudstack.api.ApiConstants;

import org.apache.cloudstack.api.ApiErrorCode;

import org.apache.cloudstack.api.ApiServerService;

import org.apache.cloudstack.api.BaseAsyncCmd;

import org.apache.cloudstack.api.BaseAsyncCreateCmd;

import org.apache.cloudstack.api.BaseCmd;

import org.apache.cloudstack.api.BaseListCmd;

import org.apache.cloudstack.api.Parameter;

import org.apache.cloudstack.api.ResponseObject;

import org.apache.cloudstack.api.ResponseObject.ResponseView;

import org.apache.cloudstack.api.ServerApiException;

import org.apache.cloudstack.api.auth.APIAuthenticationManager;

import org.apache.cloudstack.api.command.admin.host.ListHostsCmd;

import org.apache.cloudstack.api.command.admin.router.ListRoutersCmd;

import org.apache.cloudstack.api.command.admin.storage.ListStoragePoolsCmd;

import org.apache.cloudstack.api.command.admin.user.ListUsersCmd;

import org.apache.cloudstack.api.command.user.account.ListAccountsCmd;

import org.apache.cloudstack.api.command.user.account.ListProjectAccountsCmd;

import org.apache.cloudstack.api.command.user.event.ListEventsCmd;

import org.apache.cloudstack.api.command.user.offering.ListDiskOfferingsCmd;

import org.apache.cloudstack.api.command.user.offering.ListServiceOfferingsCmd;

import org.apache.cloudstack.api.command.user.project.ListProjectInvitationsCmd;

import org.apache.cloudstack.api.command.user.project.ListProjectsCmd;

import org.apache.cloudstack.api.command.user.securitygroup.ListSecurityGroupsCmd;

import org.apache.cloudstack.api.command.user.tag.ListTagsCmd;

import org.apache.cloudstack.api.command.user.vm.ListVMsCmd;

import org.apache.cloudstack.api.command.user.vmgroup.ListVMGroupsCmd;

import org.apache.cloudstack.api.command.user.volume.ListVolumesCmd;

import org.apache.cloudstack.api.command.user.zone.ListZonesCmd;

import org.apache.cloudstack.api.response.AsyncJobResponse;

import org.apache.cloudstack.api.response.CreateCmdResponse;

import org.apache.cloudstack.api.response.ExceptionResponse;

import org.apache.cloudstack.api.response.ListResponse;

import org.apache.cloudstack.api.response.LoginCmdResponse;

import org.apache.cloudstack.config.ApiServiceConfiguration;

import org.apache.cloudstack.context.CallContext;

import org.apache.cloudstack.framework.config.ConfigKey;

import org.apache.cloudstack.framework.config.Configurable;

import org.apache.cloudstack.framework.events.EventDistributor;

import org.apache.cloudstack.framework.jobs.AsyncJob;

import org.apache.cloudstack.framework.jobs.AsyncJobManager;

import org.apache.cloudstack.framework.jobs.impl.AsyncJobVO;

import org.apache.cloudstack.framework.messagebus.MessageBus;

import org.apache.cloudstack.framework.messagebus.MessageDispatcher;

import org.apache.cloudstack.framework.messagebus.MessageHandler;

import org.apache.cloudstack.managed.context.ManagedContextRunnable;

import org.apache.cloudstack.user.UserPasswordResetManager;

import org.apache.cloudstack.utils.identity.ManagementServerNode;

import org.apache.commons.codec.binary.Base64;

import org.apache.commons.lang3.EnumUtils;

import org.apache.http.ConnectionClosedException;

import org.apache.http.HttpException;

import org.apache.http.HttpRequest;

import org.apache.http.HttpResponse;

import org.apache.http.HttpServerConnection;

import org.apache.http.HttpStatus;

import org.apache.http.NameValuePair;

import org.apache.http.client.utils.URLEncodedUtils;

import org.apache.http.entity.BasicHttpEntity;

import org.apache.http.impl.DefaultHttpResponseFactory;

import org.apache.http.impl.DefaultHttpServerConnection;

import org.apache.http.impl.NoConnectionReuseStrategy;

import org.apache.http.impl.SocketHttpServerConnection;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.params.CoreConnectionPNames;

import org.apache.http.params.CoreProtocolPNames;

import org.apache.http.params.HttpParams;

import org.apache.http.protocol.BasicHttpContext;

import org.apache.http.protocol.BasicHttpProcessor;

import org.apache.http.protocol.HttpContext;

import org.apache.http.protocol.HttpRequestHandler;

import org.apache.http.protocol.HttpRequestHandlerRegistry;

import org.apache.http.protocol.HttpService;

import org.apache.http.protocol.ResponseConnControl;

import org.apache.http.protocol.ResponseContent;

import org.apache.http.protocol.ResponseDate;

import org.apache.http.protocol.ResponseServer;

import org.apache.logging.log4j.LogManager;

import org.apache.logging.log4j.Logger;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.springframework.stereotype.Component;

import com.cloud.api.dispatch.DispatchChainFactory;

import com.cloud.api.dispatch.DispatchTask;

import com.cloud.api.response.ApiResponseSerializer;

import com.cloud.domain.Domain;

import com.cloud.domain.DomainVO;

import com.cloud.domain.dao.DomainDao;

import com.cloud.event.ActionEventUtils;

import com.cloud.event.EventCategory;

import com.cloud.event.EventTypes;

import com.cloud.exception.AccountLimitException;

import com.cloud.exception.CloudAuthenticationException;

import com.cloud.exception.InsufficientCapacityException;

import com.cloud.exception.InvalidParameterValueException;

import com.cloud.exception.OriginDeniedException;

import com.cloud.exception.PermissionDeniedException;

import com.cloud.exception.RequestLimitException;

import com.cloud.exception.ResourceAllocationException;

import com.cloud.exception.ResourceUnavailableException;

import com.cloud.exception.UnavailableCommandException;

import com.cloud.projects.dao.ProjectDao;

import com.cloud.storage.VolumeApiService;

import com.cloud.utils.ConstantTimeComparator;

import com.cloud.utils.DateUtil;

import com.cloud.utils.HttpUtils;

import com.cloud.utils.HttpUtils.ApiSessionKeySameSite;

import com.cloud.utils.HttpUtils.ApiSessionKeyCheckOption;

import com.cloud.utils.Pair;

import com.cloud.utils.ReflectUtil;

import com.cloud.utils.StringUtils;

import com.cloud.utils.component.ComponentContext;

import com.cloud.utils.component.ManagerBase;

import com.cloud.utils.component.PluggableService;

import com.cloud.utils.concurrency.NamedThreadFactory;

import com.cloud.utils.db.EntityManager;

import com.cloud.utils.db.TransactionLegacy;

import com.cloud.utils.db.UUIDManager;

import com.cloud.utils.exception.CloudRuntimeException;

import com.cloud.utils.exception.ExceptionProxyObject;

import com.cloud.utils.net.NetUtils;

import com.google.gson.reflect.TypeToken;

import static com.cloud.user.AccountManagerImpl.apiKeyAccess;

import static org.apache.cloudstack.user.UserPasswordResetManager.UserPasswordResetEnabled;

@Component

public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiServerService, Configurable {

private static final String SANITIZATION_REGEX = "[\n\r]";

private static boolean encodeApiResponse = false;

/**

* Non-printable ASCII characters - numbers 0 to 31 and 127 decimal

*/

private static final String CONTROL_CHARACTERS = "[\000-\011\013-\014\016-\037\177]";

@Inject

private AccountManager accountMgr;

@Inject

private APIAuthenticationManager authManager;

@Inject

private ApiDispatcher dispatcher;

@Inject

private AsyncJobManager asyncMgr;

@Inject

private DispatchChainFactory dispatchChainFactory;

@Inject

private DomainManager domainMgr;

@Inject

private DomainDao domainDao;

@Inject

private EntityManager entityMgr;

@Inject

private ProjectDao projectDao;

@Inject

private ManagementServerHostDao msHostDao;

@Inject

private UUIDManager uuidMgr;

@Inject

private UserPasswordResetManager userPasswordResetManager;

private List<PluggableService> pluggableServices;

private List<APIChecker> apiAccessCheckers;

@Inject

private ApiAsyncJobDispatcher asyncDispatcher;

private EventDistributor eventDistributor = null;

private static int s_workerCount = 0;

private static Map<String, List<Class<?>>> s_apiNameCmdClassMap = new HashMap<String, List<Class<?>>>();

private static ExecutorService s_executor = new ThreadPoolExecutor(10, 150, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new NamedThreadFactory(

"ApiServer"));

@Inject

private MessageBus messageBus;

private static final ConfigKey<Integer> IntegrationAPIPort = new ConfigKey<>(ConfigKey.CATEGORY_ADVANCED

, Integer.class

, "integration.api.port"

, "0"

, "Integration (unauthenticated) API port. To disable set it to 0 or negative."

, false

, ConfigKey.Scope.Global);

private static final ConfigKey<Long> ConcurrentSnapshotsThresholdPerHost = new ConfigKey<>(ConfigKey.CATEGORY_ADVANCED

, Long.class

, "concurrent.snapshots.threshold.perhost"

, null

, "Limits number of snapshots that can be handled by the host concurrently; default is NULL - unlimited"

, true // not sure if this is to be dynamic

, ConfigKey.Scope.Global);

private static final ConfigKey<Boolean> EncodeApiResponse = new ConfigKey<>(ConfigKey.CATEGORY_ADVANCED

, Boolean.class

, "encode.api.response"

, "false"

, "Do URL encoding for the api response, false by default"

, false

, ConfigKey.Scope.Global);

static final ConfigKey<String> JSONcontentType = new ConfigKey<>(ConfigKey.CATEGORY_ADVANCED

, String.class

, "json.content.type"

, "application/json; charset=UTF-8"

, "Http response content type for .js files (default is text/javascript)"

, false

, ConfigKey.Scope.Global);

static final ConfigKey<Boolean> EnableSecureSessionCookie = new ConfigKey<>(ConfigKey.CATEGORY_ADVANCED

, Boolean.class

, "enable.secure.session.cookie"

, "false"

, "Session cookie is marked as secure if this is enabled. Secure cookies only work when HTTPS is used."

, false

, ConfigKey.Scope.Global);

private static final ConfigKey<String> JSONDefaultContentType = new ConfigKey<> (ConfigKey.CATEGORY_ADVANCED

, String.class

, "json.content.type"

, "application/json; charset=UTF-8"

, "Http response content type for JSON"

, false

, ConfigKey.Scope.Global);

private static final ConfigKey<Boolean> UseEventAccountInfo = new ConfigKey<>(ConfigKey.CATEGORY_ADVANCED

, Boolean.class

, "event.accountinfo"

, "false"

, "use account info in event logging"

, true

, ConfigKey.Scope.Global);

static final ConfigKey<Boolean> useForwardHeader = new ConfigKey<>(ConfigKey.CATEGORY_NETWORK

, Boolean.class

, "proxy.header.verify"

, "false"

, "enables/disables checking of ipaddresses from a proxy set header. See \"proxy.header.names\" for the headers to allow."

, true

, ConfigKey.Scope.Global);

static final ConfigKey<String> listOfForwardHeaders = new ConfigKey<>(ConfigKey.CATEGORY_NETWORK

, String.class

, "proxy.header.names"

, "X-Forwarded-For,HTTP_CLIENT_IP,HTTP_X_FORWARDED_FOR"

, "a list of names to check for allowed ipaddresses from a proxy set header. See \"proxy.cidr\" for the proxies allowed to set these headers."

, true

, ConfigKey.Scope.Global);

static final ConfigKey<String> proxyForwardList = new ConfigKey<>(ConfigKey.CATEGORY_NETWORK

, String.class

, "proxy.cidr"

, ""

, "a list of cidrs for which \"proxy.header.names\" are honoured if the \"Remote_Addr\" is in this list."

, true

, ConfigKey.Scope.Global);

static final ConfigKey<String> ApiSessionKeyCookieSameSiteSetting = new ConfigKey<>(String.class

, "api.sessionkey.cookie.samesite"

, ConfigKey.CATEGORY_ADVANCED

, ApiSessionKeySameSite.Lax.name()

, "The SameSite attribute of cookie 'sessionkey'. Valid options are: Lax (default), Strict, NoneAndSecure and Null."

, true

, ConfigKey.Scope.Global, null, null, null, null, null, ConfigKey.Kind.Select,

EnumSet.allOf(ApiSessionKeySameSite.class).stream().map(Enum::toString).collect(Collectors.joining(", ")));

public static final ConfigKey<String> ApiSessionKeyCheckLocations = new ConfigKey<>(String.class

, "api.sessionkey.check.locations"

, ConfigKey.CATEGORY_ADVANCED

, ApiSessionKeyCheckOption.CookieAndParameter.name()

, "The locations of 'sessionkey' during the validation of the API requests. Valid options are: CookieOrParameter, ParameterOnly, CookieAndParameter (default)."

, true

, ConfigKey.Scope.Global, null, null, null, null, null, ConfigKey.Kind.Select,

EnumSet.allOf(ApiSessionKeyCheckOption.class).stream().map(Enum::toString).collect(Collectors.joining(", ")));

@Override

public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException {

messageBus.subscribe(AsyncJob.Topics.JOB_EVENT_PUBLISH, MessageDispatcher.getDispatcher(this));

return true;

}

public void setEventDistributor(EventDistributor eventDistributor) {

this.eventDistributor = eventDistributor;

}

@MessageHandler(topic = AsyncJob.Topics.JOB_EVENT_PUBLISH)

public void handleAsyncJobPublishEvent(String subject, String senderAddress, Object args) {

assert (args != null);

@SuppressWarnings("unchecked")

Pair<AsyncJob, String> eventInfo = (Pair<AsyncJob, String>)args;

AsyncJob job = eventInfo.first();

String jobEvent = eventInfo.second();

if (logger.isTraceEnabled())

logger.trace("Handle asyjob publish event " + jobEvent);

if (eventDistributor == null) {

setEventDistributor(ComponentContext.getComponent(EventDistributor.class));

}

if (!job.getDispatcher().equalsIgnoreCase("ApiAsyncJobDispatcher")) {

return;

}

User userJobOwner = accountMgr.getUserIncludingRemoved(job.getUserId());

Account jobOwner = accountMgr.getAccount(userJobOwner.getAccountId());

// Get the event type from the cmdInfo json string

String info = job.getCmdInfo();

String cmdEventType = "unknown";

Map<String, Object> cmdInfoObj = new HashMap<>();

if (info != null) {

Type type = new TypeToken<Map<String, String>>(){}.getType();

Map<String, String> cmdInfo = ApiGsonHelper.getBuilder().create().fromJson(info, type);

cmdInfoObj.putAll(cmdInfo);

String eventTypeObj = cmdInfo.get("cmdEventType");

if (eventTypeObj != null) {

cmdEventType = eventTypeObj;

if (logger.isDebugEnabled())

logger.debug("Retrieved cmdEventType from job info: " + cmdEventType);

} else {

if (logger.isDebugEnabled())

logger.debug("Unable to locate cmdEventType marker in job info. publish as unknown event");

}

String contextDetails = cmdInfo.get("ctxDetails");

if(contextDetails != null) {

Type objectMapType = new TypeToken<Map<Object, Object>>() {}.getType();

Map<Object, Object> ctxDetails = ApiGsonHelper.getBuilder().create().fromJson(contextDetails, objectMapType);

cmdInfoObj.put("ctxDetails", ctxDetails);

}

}

// For some reason, the instanceType / instanceId are not abstract, which means we may get null values.

String instanceType = job.getInstanceType() != null ? job.getInstanceType() : "unknown";

String instanceUuid = job.getInstanceId() != null ? ApiDBUtils.findJobInstanceUuid(job) : "";

org.apache.cloudstack.framework.events.Event event = new org.apache.cloudstack.framework.events.Event("management-server", EventCategory.ASYNC_JOB_CHANGE_EVENT.getName(),

jobEvent, instanceType, instanceUuid);

Map<String, Object> eventDescription = new HashMap<>();

eventDescription.put("command", job.getCmd());

eventDescription.put("user", userJobOwner.getUuid());

eventDescription.put("account", jobOwner.getUuid());

eventDescription.put("processStatus", "" + job.getProcessStatus());

eventDescription.put("resultCode", "" + job.getResultCode());

eventDescription.put("instanceUuid", instanceUuid);

eventDescription.put("instanceType", instanceType);

eventDescription.put("commandEventType", cmdEventType);

eventDescription.put("jobId", job.getUuid());

eventDescription.put("jobResult", ApiSerializerHelper.fromSerializedStringToMap(job.getResult()));

eventDescription.put("cmdInfo", cmdInfoObj);

eventDescription.put("status", "" + job.getStatus());

// If the event.accountinfo boolean value is set, get the human readable value for the username / domainname

if (UseEventAccountInfo.value()) {

DomainVO domain = domainDao.findById(jobOwner.getDomainId());

eventDescription.put("username", userJobOwner.getUsername());

eventDescription.put("accountname", jobOwner.getAccountName());

eventDescription.put("domainname", domain.getName());

}

event.setDescription(eventDescription);

eventDistributor.publish(event);

}

protected void setupIntegrationPortListener(Integer apiPort) {

if (apiPort == null || apiPort <= 0) {

logger.trace(String.format("Skipping setting up listener for integration port as %s is set to %d",

IntegrationAPIPort.key(), apiPort));

return;

}

logger.debug(String.format("Setting up integration API service listener on port: %d", apiPort));

final ListenerThread listenerThread = new ListenerThread(this, apiPort);

listenerThread.start();

}

@Override

public boolean start() {

Security.addProvider(new BouncyCastleProvider());

Integer apiPort = IntegrationAPIPort.value(); // api port, null by default

final Long snapshotLimit = ConcurrentSnapshotsThresholdPerHost.value();

if (snapshotLimit == null || snapshotLimit.longValue() <= 0) {

logger.debug("Global concurrent snapshot config parameter " + ConcurrentSnapshotsThresholdPerHost.value() + " is less or equal 0; defaulting to unlimited");

} else {

dispatcher.setCreateSnapshotQueueSizeLimit(snapshotLimit);

}

final Long migrationLimit = VolumeApiService.ConcurrentMigrationsThresholdPerDatastore.value();

if (migrationLimit == null || migrationLimit.longValue() <= 0) {

logger.debug("Global concurrent migration config parameter " + VolumeApiService.ConcurrentMigrationsThresholdPerDatastore.value() + " is less or equal 0; defaulting to unlimited");

} else {

dispatcher.setMigrateQueueSizeLimit(migrationLimit);

}

final Set<Class<?>> cmdClasses = new HashSet<Class<?>>();

for (final PluggableService pluggableService : pluggableServices) {

cmdClasses.addAll(pluggableService.getCommands());

if (logger.isDebugEnabled()) {

logger.debug("Discovered plugin " + pluggableService.getClass().getSimpleName());

}

}

for (final Class<?> cmdClass : cmdClasses) {

final APICommand at = cmdClass.getAnnotation(APICommand.class);

if (at == null) {

throw new CloudRuntimeException(String.format("%s is claimed as a API command, but it doesn't have @APICommand annotation", cmdClass.getName()));

}

String apiName = at.name();

List<Class<?>> apiCmdList = s_apiNameCmdClassMap.get(apiName);

if (apiCmdList == null) {

apiCmdList = new ArrayList<Class<?>>();

s_apiNameCmdClassMap.put(apiName, apiCmdList);

}

apiCmdList.add(cmdClass);

}

setEncodeApiResponse(EncodeApiResponse.value());

setupIntegrationPortListener(apiPort);

return true;

}

// NOTE: handle() only handles over the wire (OTW) requests from integration.api.port 8096

// If integration api port is not configured, actual OTW requests will be received by ApiServlet

@SuppressWarnings({"unchecked", "rawtypes"})

@Override

public void handle(final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException {

// Create StringBuffer to log information in access log

final StringBuilder sb = new StringBuilder();

final HttpServerConnection connObj = (HttpServerConnection)context.getAttribute("http.connection");

if (connObj instanceof SocketHttpServerConnection) {

final InetAddress remoteAddr = ((SocketHttpServerConnection)connObj).getRemoteAddress();

sb.append(remoteAddr.toString() + " -- ");

}

sb.append(StringUtils.cleanString(request.getRequestLine().toString()));

try {

List<NameValuePair> paramList = null;

try {

paramList = URLEncodedUtils.parse(new URI(request.getRequestLine().getUri()), HttpUtils.UTF_8);

} catch (final URISyntaxException e) {

logger.error("Error parsing url request", e);

}

// Use Multimap as the parameter map should be in the form (name=String, value=String[])

// So parameter values are stored in a list for the same name key

// APITODO: Use Guava's (import com.google.common.collect.Multimap;)

// (Immutable)Multimap<String, String> paramMultiMap = HashMultimap.create();

// Map<String, Collection<String>> parameterMap = paramMultiMap.asMap();

final Map parameterMap = new HashMap<String, String[]>();

String responseType = HttpUtils.RESPONSE_TYPE_XML;

if(paramList != null) {

for (final NameValuePair param : paramList) {

if (param.getName().equalsIgnoreCase("response")) {

responseType = param.getValue();

continue;

}

if(parameterMap.putIfAbsent(param.getName(), new String[]{param.getValue()}) != null) {

String message = String.format("Query parameter '%s' has multiple values [%s, %s]. Only the last value will be respected." +

"It is advised to pass only a single parameter", param.getName(), param.getValue(), parameterMap.get(param.getName()));

logger.warn(StringUtils.cleanString(message));

}

}

}

// Get the type of http method being used.

parameterMap.put("httpmethod", new String[] {request.getRequestLine().getMethod()});

// Check responseType, if not among valid types, fallback to JSON

if (!(responseType.equals(HttpUtils.RESPONSE_TYPE_JSON) || responseType.equals(HttpUtils.RESPONSE_TYPE_XML))) {

responseType = HttpUtils.RESPONSE_TYPE_XML;

}

try {

//verify that parameter is legit for passing via admin port

String[] command = (String[]) parameterMap.get("command");

if (command != null) {

Class<?> cmdClass = getCmdClass(command[0]);

if (cmdClass != null) {

List<Field> fields = ReflectUtil.getAllFieldsForClass(cmdClass, BaseCmd.class);

for (Field field : fields) {

Parameter parameterAnnotation = field.getAnnotation(Parameter.class);

if ((parameterAnnotation == null) || !parameterAnnotation.expose()) {

continue;

}

Object paramObj = parameterMap.get(parameterAnnotation.name());

if (paramObj != null) {

if (!parameterAnnotation.acceptedOnAdminPort()) {

throw new ServerApiException(ApiErrorCode.ACCOUNT_ERROR, "Parameter " + parameterAnnotation.name() + " can't be passed through the API integration port");

}

}

}

}

}

// always trust commands from API port, user context will always be UID_SYSTEM/ACCOUNT_ID_SYSTEM

CallContext.register(accountMgr.getSystemUser(), accountMgr.getSystemAccount());

sb.insert(0, "(userId=" + User.UID_SYSTEM + " accountId=" + Account.ACCOUNT_ID_SYSTEM + " sessionId=" + null + ") ");

final String responseText = handleRequest(parameterMap, responseType, sb);

sb.append(" 200 " + ((responseText == null) ? 0 : responseText.length()));

writeResponse(response, responseText, HttpStatus.SC_OK, responseType, null);

} catch (final ServerApiException se) {

final String responseText = getSerializedApiError(se, parameterMap, responseType);

writeResponse(response, responseText, se.getErrorCode().getHttpCode(), responseType, se.getDescription());

sb.append(" " + se.getErrorCode() + " " + se.getDescription());

} catch (final RuntimeException e) {

// log runtime exception like NullPointerException to help identify the source easier

logger.error("Unhandled exception, ", e);

throw e;

}

} finally {

logger.info(sb.toString());

CallContext.unregister();

}

}

@SuppressWarnings({"unchecked", "rawtypes"})

public void checkCharacterInkParams(final Map params) {

final Map<String, String> stringMap = new HashMap<String, String>();

final Set keys = params.keySet();

final Iterator keysIter = keys.iterator();

while (keysIter.hasNext()) {

final String key = (String)keysIter.next();

final String[] value = (String[])params.get(key);

// fail if parameter value contains ASCII control (non-printable) characters

if (value[0] != null && !ApiConstants.ACTIVATION_RULE.equals(key)) {

final Pattern pattern = Pattern.compile(CONTROL_CHARACTERS);

final Matcher matcher = pattern.matcher(value[0]);

if (matcher.find()) {

throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Received value containing illegal ASCII non-printable characters for parameter " + key);

}

}

stringMap.put(key, value[0]);

}

}

@Override

@SuppressWarnings("rawtypes")

public String handleRequest(final Map params, final String responseType, final StringBuilder auditTrailSb) throws ServerApiException {

checkCharacterInkParams(params);

String response = null;

String[] command = null;

try {

command = (String[])params.get("command");

if (command == null) {

logger.error("invalid request, no command sent");

if (logger.isTraceEnabled()) {

logger.trace("dumping request parameters");

for (final Object key : params.keySet()) {

final String keyStr = (String)key;

final String[] value = (String[])params.get(key);

logger.trace(" key: " + keyStr + ", value: " + ((value == null) ? "'null'" : value[0]));

}

}

throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "Invalid request, no command sent");

} else {

// Don't allow Login/Logout APIs to go past this point

if (authManager.getAPIAuthenticator(command[0]) != null) {

return null;

}

final Map<String, String> paramMap = new HashMap<String, String>();

final Set keys = params.keySet();

final Iterator keysIter = keys.iterator();

while (keysIter.hasNext()) {

final String key = (String)keysIter.next();

if ("command".equalsIgnoreCase(key)) {

continue;

}

final String[] value = (String[])params.get(key);

paramMap.put(key, value[0]);

}

Class<?> cmdClass = getCmdClass(command[0]);

if (cmdClass != null) {

APICommand annotation = cmdClass.getAnnotation(APICommand.class);

if (annotation == null) {

logger.error("No APICommand annotation found for class " + cmdClass.getCanonicalName());

throw new CloudRuntimeException("No APICommand annotation found for class " + cmdClass.getCanonicalName());

}

BaseCmd cmdObj = (BaseCmd)cmdClass.newInstance();

cmdObj = ComponentContext.inject(cmdObj);

cmdObj.configure();

cmdObj.setFullUrlParams(paramMap);

cmdObj.setResponseType(responseType);

cmdObj.setHttpMethod(paramMap.get(ApiConstants.HTTPMETHOD).toString());

// This is where the command is either serialized, or directly dispatched

StringBuilder log = new StringBuilder();

response = queueCommand(cmdObj, paramMap, log);

buildAuditTrail(auditTrailSb, command[0], log.toString());

} else {

final String errorString = "Unknown API command: " + command[0];

logger.warn(errorString);

auditTrailSb.append(" " + errorString);

throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, errorString);

}

}

} catch (final InvalidParameterValueException ex) {

logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ex.getMessage(), ex);

} catch (final IllegalArgumentException ex) {

logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ex.getMessage(), ex);

} catch (final PermissionDeniedException ex) {

final ArrayList<ExceptionProxyObject> idList = ex.getIdProxyList();

if (idList != null) {

final StringBuffer buf = new StringBuffer();

for (final ExceptionProxyObject obj : idList) {

buf.append(obj.getDescription());

buf.append(":");

buf.append(obj.getUuid());

buf.append(" ");

}

logger.info("PermissionDenied: " + ex.getMessage() + " on objs: [" + buf.toString() + "]");

} else {

logger.info("PermissionDenied: " + ex.getMessage());

}

throw new ServerApiException(ApiErrorCode.ACCOUNT_ERROR, ex.getMessage(), ex);

} catch (final AccountLimitException ex) {

logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.ACCOUNT_RESOURCE_LIMIT_ERROR, ex.getMessage(), ex);

} catch (final InsufficientCapacityException ex) {

logger.info(ex.getMessage());

String errorMsg = ex.getMessage();

if (!accountMgr.isRootAdmin(CallContext.current().getCallingAccount().getId())) {

// hide internal details to non-admin user for security reason

errorMsg = BaseCmd.USER_ERROR_MESSAGE;

}

throw new ServerApiException(ApiErrorCode.INSUFFICIENT_CAPACITY_ERROR, errorMsg, ex);

} catch (final ResourceAllocationException ex) {

logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.RESOURCE_ALLOCATION_ERROR, ex.getMessage(), ex);

} catch (final ResourceUnavailableException ex) {

logger.info(ex.getMessage());

String errorMsg = ex.getMessage();

if (!accountMgr.isRootAdmin(CallContext.current().getCallingAccount().getId())) {

// hide internal details to non-admin user for security reason

errorMsg = BaseCmd.USER_ERROR_MESSAGE;

}

throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, errorMsg, ex);

} catch (final ServerApiException ex) {

logger.info(ex.getDescription());

throw ex;

} catch (final Exception ex) {

logger.error("unhandled exception executing api command: " + ((command == null) ? "null" : command), ex);

String errorMsg = ex.getMessage();

if (!accountMgr.isRootAdmin(CallContext.current().getCallingAccount().getId())) {

// hide internal details to non-admin user for security reason

errorMsg = BaseCmd.USER_ERROR_MESSAGE;

}

throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, errorMsg, ex);

}

return response;

}

private String getBaseAsyncResponse(final long jobId, final BaseAsyncCmd cmd) {

final AsyncJobResponse response = new AsyncJobResponse();

final AsyncJob job = entityMgr.findByIdIncludingRemoved(AsyncJob.class, jobId);

response.setJobId(job.getUuid());

response.setResponseName(cmd.getCommandName());

return ApiResponseSerializer.toSerializedString(response, cmd.getResponseType());

}

private String getBaseAsyncCreateResponse(final long jobId, final BaseAsyncCreateCmd cmd, final String objectUuid) {

final CreateCmdResponse response = new CreateCmdResponse();

final AsyncJob job = entityMgr.findByIdIncludingRemoved(AsyncJob.class, jobId);

response.setJobId(job.getUuid());

response.setId(objectUuid);

response.setResponseName(cmd.getCommandName());

return ApiResponseSerializer.toSerializedString(response, cmd.getResponseType());

}

private String queueCommand(final BaseCmd cmdObj, final Map<String, String> params, StringBuilder log) throws Exception {

final CallContext ctx = CallContext.current();

final Long callerUserId = ctx.getCallingUserId();

final Account caller = ctx.getCallingAccount();

// Queue command based on Cmd super class:

// BaseCmd: cmd is dispatched to ApiDispatcher, executed, serialized and returned.

// BaseAsyncCreateCmd: cmd params are processed and create() is called, then same workflow as BaseAsyncCmd.

// BaseAsyncCmd: cmd is processed and submitted as an AsyncJob, job related info is serialized and returned.

if (cmdObj instanceof BaseAsyncCmd) {

Long objectId = null;

String objectUuid = null;

if (cmdObj instanceof BaseAsyncCreateCmd) {

final BaseAsyncCreateCmd createCmd = (BaseAsyncCreateCmd)cmdObj;

dispatcher.dispatchCreateCmd(createCmd, params);

objectId = createCmd.getEntityId();

objectUuid = createCmd.getEntityUuid();

params.put("id", objectId.toString());

Class entityClass = EventTypes.getEntityClassForEvent(createCmd.getEventType());

if (entityClass != null)

ctx.putContextParameter(entityClass, objectUuid);

} else {

// Extract the uuid before params are processed and id reflects internal db id

objectUuid = params.get(ApiConstants.ID);

dispatchChainFactory.getStandardDispatchChain().dispatch(new DispatchTask(cmdObj, params));

}

final BaseAsyncCmd asyncCmd = (BaseAsyncCmd)cmdObj;

if (callerUserId != null) {

params.put("ctxUserId", callerUserId.toString());

}

if (caller != null) {

params.put("ctxAccountId", String.valueOf(caller.getId()));

}

if (objectUuid != null) {

params.put("uuid", objectUuid);

}

long startEventId = ctx.getStartEventId();

asyncCmd.setStartEventId(startEventId);

// save the scheduled event

final Long eventId =

ActionEventUtils.onScheduledActionEvent((callerUserId == null) ? (Long)User.UID_SYSTEM : callerUserId, asyncCmd.getEntityOwnerId(), asyncCmd.getEventType(),

asyncCmd.getEventDescription(), asyncCmd.getApiResourceId(), asyncCmd.getApiResourceType().toString(), asyncCmd.isDisplay(), startEventId);

if (startEventId == 0) {

// There was no create event before, set current event id as start eventId

startEventId = eventId;

}

params.put("ctxStartEventId", String.valueOf(startEventId));

params.put("cmdEventType", asyncCmd.getEventType().toString());

params.put("ctxDetails", ApiGsonHelper.getBuilder().create().toJson(ctx.getContextParameters()));

if (asyncCmd.getHttpMethod() != null) {

params.put(ApiConstants.HTTPMETHOD, asyncCmd.getHttpMethod().toString());

}

Long instanceId = (objectId == null) ? asyncCmd.getApiResourceId() : objectId;

// users can provide the job id they want to use, so log as it is a uuid and is unique

String injectedJobId = asyncCmd.getInjectedJobId();

uuidMgr.checkUuidSimple(injectedJobId, AsyncJob.class);

AsyncJobVO job = new AsyncJobVO("", callerUserId, caller.getId(), cmdObj.getClass().getName(),

ApiGsonHelper.getBuilder().create().toJson(params), instanceId,

asyncCmd.getApiResourceType() != null ? asyncCmd.getApiResourceType().toString() : null,

injectedJobId);

job.setDispatcher(asyncDispatcher.getName());

final long jobId = asyncMgr.submitAsyncJob(job);

if (jobId == 0L) {

final String errorMsg = "Unable to schedule async job for command " + job.getCmd();

logger.warn(errorMsg);

throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, errorMsg);

}

final String response;

if (objectId != null) {

final String objUuid = (objectUuid == null) ? objectId.toString() : objectUuid;

response = getBaseAsyncCreateResponse(jobId, (BaseAsyncCreateCmd)asyncCmd, objUuid);

} else {

SerializationContext.current().setUuidTranslation(true);

response = getBaseAsyncResponse(jobId, asyncCmd);

}

// Always log response for async for now, I don't think any sensitive data will be in here.

// It might be nice to send this through scrubbing similar to how

// ApiResponseSerializer.toSerializedStringWithSecureLogs works. For now, this gets jobid's

// in the api logs.

log.append(response);

return response;

} else {

dispatcher.dispatch(cmdObj, params, false);

// if the command is of the listXXXCommand, we will need to also return the

// the job id and status if possible

// For those listXXXCommand which we have already created DB views, this step is not needed since async job is joined in their db views.

if (cmdObj instanceof BaseListCmd && !(cmdObj instanceof ListVMsCmd) && !(cmdObj instanceof ListRoutersCmd)

&& !(cmdObj instanceof ListSecurityGroupsCmd) &&

!(cmdObj instanceof ListTagsCmd) && !(cmdObj instanceof ListEventsCmd) && !(cmdObj instanceof ListVMGroupsCmd) && !(cmdObj instanceof ListProjectsCmd) &&

!(cmdObj instanceof ListProjectAccountsCmd) && !(cmdObj instanceof ListProjectInvitationsCmd) && !(cmdObj instanceof ListHostsCmd) &&

!(cmdObj instanceof ListVolumesCmd) && !(cmdObj instanceof ListUsersCmd) && !(cmdObj instanceof ListAccountsCmd)

&& !(cmdObj instanceof ListStoragePoolsCmd) && !(cmdObj instanceof ListDiskOfferingsCmd) && !(cmdObj instanceof ListServiceOfferingsCmd) &&

!(cmdObj instanceof ListZonesCmd)) {

buildAsyncListResponse((BaseListCmd)cmdObj, caller);

}

SerializationContext.current().setUuidTranslation(true);

return ApiResponseSerializer.toSerializedStringWithSecureLogs((ResponseObject)cmdObj.getResponseObject(), cmdObj.getResponseType(), log);

}

}

@SuppressWarnings("unchecked")

private void buildAsyncListResponse(final BaseListCmd command, final Account account) {

final List<ResponseObject> responses = ((ListResponse)command.getResponseObject()).getResponses();

if (responses != null && responses.size() > 0) {

List<? extends AsyncJob> jobs = null;

// list all jobs for ROOT admin

if (accountMgr.isRootAdmin(account.getId())) {

jobs = asyncMgr.findInstancePendingAsyncJobs(command.getApiResourceType().toString(), null);

} else {

jobs = asyncMgr.findInstancePendingAsyncJobs(command.getApiResourceType().toString(), account.getId());

}

if (jobs.size() == 0) {

return;

}

final Map<String, AsyncJob> objectJobMap = new HashMap<String, AsyncJob>();

for (final AsyncJob job : jobs) {

if (job.getInstanceId() == null) {

continue;

}

final String instanceUuid = ApiDBUtils.findJobInstanceUuid(job);

objectJobMap.put(instanceUuid, job);

}

for (final ResponseObject response : responses) {

if (response.getObjectId() != null && objectJobMap.containsKey(response.getObjectId())) {

final AsyncJob job = objectJobMap.get(response.getObjectId());

response.setJobId(job.getUuid());

response.setJobStatus(job.getStatus().ordinal());

}

}

}

}

private void buildAuditTrail(final StringBuilder auditTrailSb, final String command, final String result) {

if (result == null) {

return;

}

auditTrailSb.append(" " + HttpServletResponse.SC_OK + " ");

if (command.equals("createSSHKeyPair")) {

auditTrailSb.append("This result was not logged because it contains sensitive data.");

} else {

auditTrailSb.append(result);

}

}

protected boolean verifyApiKeyAccessAllowed(User user, Account account) {

Boolean apiKeyAccessEnabled = user.getApiKeyAccess();

if (apiKeyAccessEnabled != null) {

if (Boolean.TRUE.equals(apiKeyAccessEnabled)) {

return true;

} else {

logger.info("Api-Key access is disabled for the User " + user.toString());

return false;

}

}

apiKeyAccessEnabled = account.getApiKeyAccess();

if (apiKeyAccessEnabled != null) {

if (Boolean.TRUE.equals(apiKeyAccessEnabled)) {

return true;

} else {

logger.info("Api-Key access is disabled for the Account " + account.toString());

return false;

}

}

apiKeyAccessEnabled = apiKeyAccess.valueIn(account.getDomainId());

if (Boolean.TRUE.equals(apiKeyAccessEnabled)) {

return true;

} else {

logger.info("Api-Key access is disabled by the Domain level setting api.key.access");

}

return false;

}

@Override

public boolean verifyRequest(final Map<String, Object[]> requestParameters, final Long userId, InetAddress remoteAddress) throws ServerApiException {

try {

String apiKey = null;

String secretKey = null;

String signature = null;

String unsignedRequest = null;

final String[] command = (String[])requestParameters.get(ApiConstants.COMMAND);

if (command == null) {

logger.info("missing command, ignoring request...");

return false;

}

final String commandName = command[0];

// if userId not null, that mean that user is logged in

if (userId != null) {

final User user = ApiDBUtils.findUserById(userId);

return commandAvailable(remoteAddress, commandName, user);

} else {

// check against every available command to see if the command exists or not

if (!s_apiNameCmdClassMap.containsKey(commandName) && !commandName.equals("login") && !commandName.equals("logout")) {

final String errorMessage = "The given command " + commandName + " either does not exist, is not available" +

" for user, or not available from ip address '" + remoteAddress.getHostAddress() + "'.";

logger.debug(errorMessage);

return false;

}

}

// - build a request string with sorted params, make sure it's all lowercase

// - sign the request, verify the signature is the same

final List<String> parameterNames = new ArrayList<String>();

for (final Object paramNameObj : requestParameters.keySet()) {

parameterNames.add((String)paramNameObj); // put the name in a list that we'll sort later

}

Collections.sort(parameterNames);

String signatureVersion = null;

String expires = null;

for (final String paramName : parameterNames) {

// parameters come as name/value pairs in the form String/String[]

final String paramValue = ((String[])requestParameters.get(paramName))[0];

if (ApiConstants.SIGNATURE.equalsIgnoreCase(paramName)) {

signature = paramValue;

} else {

if (ApiConstants.API_KEY.equalsIgnoreCase(paramName)) {

apiKey = paramValue;

} else if (ApiConstants.SIGNATURE_VERSION.equalsIgnoreCase(paramName)) {

signatureVersion = paramValue;

} else if (ApiConstants.EXPIRES.equalsIgnoreCase(paramName)) {

expires = paramValue;

}

if (unsignedRequest == null) {

unsignedRequest = paramName + "=" + URLEncoder.encode(paramValue, HttpUtils.UTF_8).replaceAll("\\+", "%20");

} else {

unsignedRequest = unsignedRequest + "&" + paramName + "=" + URLEncoder.encode(paramValue, HttpUtils.UTF_8).replaceAll("\\+", "%20");

}

}

}

// if api/secret key are passed to the parameters

if ((signature == null) || (apiKey == null)) {

logger.debug("Expired session, missing signature, or missing apiKey -- ignoring request. Signature: " + signature + ", apiKey: " + apiKey);