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().trim().equals("*") || 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.getOid().equals(sid)) {
 101                     return true;
 102                 }
 103                 if (aclTable.getAclist() == null) {
 104                     return false;
 105                 }
 106
 107                 for (Ace ace : aclTable.getAclist()) {
 108                     if (ace.getSubjectuuid().equals(sid)) {
 109                         // check permission matches
 110                         if (checkPermission(ace.getPermission(), rm.toLowerCase())) {
 111                             // check resource uri matches
 112                             if (checkResourceUri(ace.getResources(), uri)) {
 113                                 return true;
 114                             }
 115                         }
 116                     }
 117                 }
 118             }
 119             return false;
 120         }
 121
 122     private IResponse handleGetRequest(IRequest request) throws ServerException {
 123
 124         String sid = null;
 125         String di = null;
 126         String rm = null;
 127         String uri = null;
 128
 129         if (getUriPathSegments().containsAll(request.getUriPathSegments())) {
 130             sid = request.getUriQueryMap().get(Constants.REQ_SEARCH_USER_ID)
 131                 .get(0);
 132             di = request.getUriQueryMap().get(Constants.REQ_DEVICE_ID).get(0);
 133             rm = request.getUriQueryMap().get(Constants.REQ_REQUEST_METHOD)
 134                 .get(0);
 135             uri = request.getUriQueryMap().get(Constants.REQ_REQUEST_URI)
 136                 .get(0);
 137         } else {
 138             throw new BadRequestException("uriPath is invalid");
 139         }
 140
 141         HashMap<String, Object> responsePayload = new HashMap<>();
 142         if (verifyAcl(sid, di, rm, uri)) {
 143             responsePayload.put("gp", Constants.RESP_ACL_ALLOWED);
 144         } else {
 145             responsePayload.put("gp", Constants.RESP_ACL_DENIED);
 146         }
 147
 148         return MessageBuilder.createResponse(request, ResponseStatus.CONTENT,
 149                 ContentFormat.APPLICATION_CBOR,
 150                 mCbor.encodingPayloadToCbor(responsePayload));
 151     }
 152
 153 }