cloud/account/src/main/java/org/iotivity/cloud/accountserver/resources/acl/verify/AclVerifyResource.java

   1 package org.iotivity.cloud.accountserver.resources.acl.verify;
   2
   3 import java.util.ArrayList;
   4 import java.util.Arrays;
   5 import java.util.HashMap;
   6 import java.util.List;
   7
   8 import org.iotivity.cloud.accountserver.Constants;
   9 import org.iotivity.cloud.accountserver.db.AccountDBManager;
  10 import org.iotivity.cloud.accountserver.db.AclTable;
  11 import org.iotivity.cloud.accountserver.resources.acl.id.Ace;
  12 import org.iotivity.cloud.accountserver.resources.acl.id.AceResource;
  13 import org.iotivity.cloud.accountserver.resources.acl.id.Acl;
  14 import org.iotivity.cloud.accountserver.util.TypeCastingManager;
  15 import org.iotivity.cloud.base.device.Device;
  16 import org.iotivity.cloud.base.exception.ServerException;
  17 import org.iotivity.cloud.base.exception.ServerException.BadRequestException;
  18 import org.iotivity.cloud.base.exception.ServerException.PreconditionFailedException;
  19 import org.iotivity.cloud.base.protocols.IRequest;
  20 import org.iotivity.cloud.base.protocols.IResponse;
  21 import org.iotivity.cloud.base.protocols.MessageBuilder;
  22 import org.iotivity.cloud.base.protocols.enums.ContentFormat;
  23 import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
  24 import org.iotivity.cloud.base.resource.Resource;
  25 import org.iotivity.cloud.util.Cbor;
  26
  27 public class AclVerifyResource extends Resource {
  28
  29     private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
  30
  31     public AclVerifyResource() {
  32         super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACL_URI,
  33                     Constants.VERIFY_URI));
  34     }
  35
  36     @Override
  37         public void onDefaultRequestReceived(Device srcDevice, IRequest request)
  38         throws ServerException {
  39
  40             IResponse response = null;
  41
  42             switch (request.getMethod()) {
  43                 case GET:
  44                     response = handleGetRequest(request);
  45                     break;
  46                 default:
  47                     throw new BadRequestException(request.getMethod()
  48                             + " request type is not supported");
  49             }
  50
  51             srcDevice.sendResponse(response);
  52         }
  53
  54     private boolean checkPermission(int permissionValue, String rme)
  55         throws ServerException {
  56             Permission per = null;
  57             int rm_value = 0;
  58             if (rme.equals("get")) {
  59                 per = Permission.Read;
  60             } else if (rme.equals("post")) {
  61                 per = Permission.Update;
  62             } else if (rme.equals("delete")) {
  63                 per = Permission.Delete;
  64             }
  65             if (per != null) {
  66                 rm_value = per.getValue();
  67             }
  68             // bit and operation
  69             return ((permissionValue & rm_value) == rm_value);
  70         }
  71
  72     private boolean checkResourceUri(List<AceResource> aceResources, String uri)
  73         throws ServerException {
  74             for (AceResource aceResource : aceResources) {
  75                 if (aceResource.getHref().equals(uri)) {
  76                     return true;
  77                 }
  78             }
  79             return false;
  80         }
  81
  82     private boolean verifyAcl(String sid, String di, String rm, String uri)
  83         throws ServerException {
  84
  85             HashMap<String, Object> condition = new HashMap<>();
  86             condition.put(Constants.KEYFIELD_DI, di);
  87
  88             // Query AclTable with condition deviceId(di)
  89             ArrayList<HashMap<String, Object>> aclResult = AccountDBManager
  90                 .getInstance().selectRecord(Constants.ACL_TABLE, condition);
  91
  92             // if aclResult size is zero then (di) does not exist
  93             if (aclResult == null || aclResult.size() == 0) {
  94                 return false;
  95             }
  96
  97             for (HashMap<String, Object> eachAclMap : aclResult) {
  98
  99                 AclTable aclTable = Acl.convertMaptoAclObject(eachAclMap);
 100                 if (aclTable.getAclist() == null) {
 101                     return false;
 102                 }
 103                 if (aclTable.getOid().equals(sid)) {
 104                     return true;
 105                 }
 106                 for (Ace ace : aclTable.getAclist()) {
 107                     if (ace.getSubjectuuid().equals(sid)) {
 108                         // check permission matches
 109                         if (checkPermission(ace.getPermission(), rm.toLowerCase())) {
 110                             // check resource uri matches
 111                             if (checkResourceUri(ace.getResources(), uri)) {
 112                                 return true;
 113                             }
 114                         }
 115                     }
 116                 }
 117             }
 118             return false;
 119         }
 120
 121     private IResponse handleGetRequest(IRequest request) throws ServerException {
 122
 123         String sid = null;
 124         String di = null;
 125         String rm = null;
 126         String uri = null;
 127
 128         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
 129             sid = request.getUriQueryMap().get(Constants.REQ_SEARCH_USER_ID)
 130                 .get(0);
 131             di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID).get(0);
 132             rm = request.getUriQueryMap().get(Constants.REQ_REQUEST_METHOD)
 133                 .get(0);
 134             uri = request.getUriQueryMap().get(Constants.REQ_REQUEST_URI)
 135                 .get(0);
 136         } else {
 137             throw new BadRequestException("uriPath is invalid");
 138         }
 139
 140         HashMap<String, Object> responsePayload = new HashMap<>();
 141         if (verifyAcl(sid, di, rm, uri)) {
 142             responsePayload.put("gp", Constants.RESP_ACL_ALLOWED);
 143         } else {
 144             responsePayload.put("gp", Constants.RESP_ACL_DENIED);
 145         }
 146
 147         return MessageBuilder.createResponse(request, ResponseStatus.CONTENT,
 148                 ContentFormat.APPLICATION_CBOR,
 149                 mCbor.encodingPayloadToCbor(responsePayload));
 150     }
 151
 152 }