lib: tmonior: Implement the missing API

Implement the following tmonitor API:
- tmonitor_delete_resouce()		: REQUEST_DELETE_RESOURCE
- tmonitor_get_resouce_count()		: REQUEST_GET_RESOURCE_COUNT
- tmonitor_update()			: REQUEST_UPDATE_RESOURCE_ALL
- tmonitor_unset_resource_attr		: REQUEST_UNSET_RESOURCE_ATTR
- tmoniotr_is_resource_attr_supported()	: REQUEST_IS_RESOURCE_ATTR_SUPPORTED

Change-Id: Id068940632c4bbd5bae79d907e77f846fff4a042
Signed-off-by: Chanwoo Choi <cw00.choi@samsung.com>

diff --git a/lib/tmonitor/tmonitor.c b/lib/tmonitor/tmonitor.c
index 2e74090..fa6b22b 100644 (file)
--- a/lib/tmonitor/tmonitor.c
+++ b/lib/tmonitor/tmonitor.c
@@ -94,6 +94,39 @@ static struct tmonitor_client *find_client_by_id(int id)
        return NULL;
 }
 
+static int handle_resource_attr(int request, int id, int resource_id, u_int64_t attr_mask)
+{
+       char buffer[MAX_BUF_SIZE + 1];
+       int buffer_len;
+       int response_req;
+       int ret;
+
+       buffer_len = sprintf(buffer, "%d:%d:%"PRIu64,
+                       request, resource_id, attr_mask);
+       if (send(id, buffer, buffer_len, 0) < 0) {
+               _E("[libpass] error occurred while sending buffer");
+               return -EIO;
+       }
+
+       /* wait for response */
+       buffer_len = recv(id, buffer, MAX_BUF_SIZE, 0);
+       if (buffer_len <= 0) {
+               _E("[libpass] socket disconnected");
+               return -EIO;
+       }
+
+       buffer[buffer_len] = '\0';
+       if (sscanf(buffer, "%d:%d", &response_req, &ret) < 2)
+               return -EINVAL;
+
+       if (response_req != request) {
+               _E("[libpass] wrong response");
+               return -EINVAL;
+       }
+
+       return ret;
+}
+
 EXPORT
 int tmonitor_init(void)
 {
@@ -161,7 +194,35 @@ int tmonitor_exit(int id)
 EXPORT
 int tmonitor_get_resource_count(int id, int resource_type)
 {
-       return 0;
+       char buffer[MAX_BUF_SIZE + 1];
+       int buffer_len;
+       int response_req;
+       int ret;
+
+       buffer_len = sprintf(buffer, "%d:%d",
+                       REQUEST_GET_RESOURCE_COUNT, resource_type);
+       if (send(id, buffer, buffer_len, 0) < 0) {
+               _E("[libpass] error occurred while sending buffer");
+               return -EIO;
+       }
+
+       /* wait for response */
+       buffer_len = recv(id, buffer, MAX_BUF_SIZE, 0);
+       if (buffer_len <= 0) {
+               _E("[libpass] socket disconnected");
+               return -EIO;
+       }
+
+       buffer[buffer_len] = '\0';
+       if (sscanf(buffer, "%d:%d", &response_req, &ret) < 2)
+               return -EINVAL;
+
+       if (response_req != REQUEST_GET_RESOURCE_COUNT) {
+               _E("[libpass] wrong response");
+               return -EINVAL;
+       }
+
+       return ret;
 }
 
 EXPORT
@@ -200,7 +261,34 @@ int tmonitor_create_resource(int id, int resource_type)
 EXPORT
 int tmonitor_delete_resource(int id, int resource_id)
 {
-       return 0;
+       char buffer[MAX_BUF_SIZE + 1];
+       int buffer_len;
+       int response_req;
+       int ret;
+
+       buffer_len = sprintf(buffer, "%d:%d", REQUEST_DELETE_RESOURCE, resource_id);
+       if (send(id, buffer, buffer_len, 0) < 0) {
+               _E("[libpass] error occurred while sending buffer for create resource");
+               return -EIO;
+       }
+
+       /* wait for response */
+       buffer_len = recv(id, buffer, MAX_BUF_SIZE, 0);
+       if (buffer_len <= 0) {
+               _E("[libpass] socket disconnected");
+               return -EIO;
+       }
+
+       buffer[buffer_len] = '\0';
+       if (sscanf(buffer, "%d:%d", &response_req, &ret) < 2)
+               return -EINVAL;
+
+       if (response_req != REQUEST_DELETE_RESOURCE) {
+               _E("wrong response");
+               return -EINVAL;
+       }
+
+       return ret;
 }
 
 EXPORT
@@ -240,13 +328,25 @@ int tmonitor_set_resource_ctrl(int id, int resource_id, u_int64_t ctrl_id, int v
 EXPORT
 int tmonitor_set_resource_attr(int id, int resource_id, u_int64_t attr_mask)
 {
+       return handle_resource_attr(REQUEST_SET_RESOURCE_ATTR, id, resource_id, attr_mask);
+}
+
+EXPORT
+int tmonitor_unset_resource_attr(int id, int resource_id, u_int64_t attr_mask)
+{
+       return handle_resource_attr(REQUEST_UNSET_RESOURCE_ATTR, id, resource_id, attr_mask);
+}
+
+EXPORT
+bool tmonitor_is_resource_attr_supported(int id, int resource_id, u_int64_t attr_id)
+{
        char buffer[MAX_BUF_SIZE + 1];
        int buffer_len;
        int response_req;
        int ret;
 
-       buffer_len = sprintf(buffer, "%d:%d:%"PRIu64,
-                       REQUEST_SET_RESOURCE_ATTR, resource_id, attr_mask);
+       buffer_len = sprintf(buffer, "%d:%d:%"PRIu64"",
+                       REQUEST_IS_RESOURCE_ATTR_SUPPORTED, resource_id, attr_id);
        if (send(id, buffer, buffer_len, 0) < 0) {
                _E("[libpass] error occurred while sending buffer");
                return -EIO;
@@ -263,30 +363,45 @@ int tmonitor_set_resource_attr(int id, int resource_id, u_int64_t attr_mask)
        if (sscanf(buffer, "%d:%d", &response_req, &ret) < 2)
                return -EINVAL;
 
-       if (response_req != REQUEST_SET_RESOURCE_ATTR) {
+       if (response_req != REQUEST_IS_RESOURCE_ATTR_SUPPORTED) {
                _E("[libpass] wrong response");
                return -EINVAL;
        }
 
-       return ret;
+       return (bool)ret;
 }
 
 EXPORT
-int tmonitor_unset_resource_attr(int id, int resource_id, u_int64_t attr_mask)
+int tmonitor_update(int id)
 {
-       return 0;
-}
+       char buffer[MAX_BUF_SIZE + 1];
+       int buffer_len;
+       int response_req;
+       int ret;
 
-EXPORT
-bool tmonitor_is_resource_attr_supported(int id, int resource_id, u_int64_t attr_id)
-{
-       return 0;
-}
+       buffer_len = sprintf(buffer, "%d", REQUEST_UPDATE_RESOURCE_ALL);
+       if (send(id, buffer, buffer_len, 0) < 0) {
+               _E("[libpass] error occurred while sending buffer");
+               return -EIO;
+       }
 
-EXPORT
-int tmonitor_update(int id)
-{
-       return 0;
+       /* wait for response */
+       buffer_len = recv(id, buffer, MAX_BUF_SIZE, 0);
+       if (buffer_len <= 0) {
+               _E("[libpass] socket disconnected");
+               return -EIO;
+       }
+
+       buffer[buffer_len] = '\0';
+       if (sscanf(buffer, "%d:%d", &response_req, &ret) < 2)
+               return -EINVAL;
+
+       if (response_req != REQUEST_UPDATE_RESOURCE_ALL) {
+               _E("[libpass] wrong response");
+               return -EINVAL;
+       }
+
+       return ret;
 }
 
 EXPORT

diff --git a/src/monitor/request-handler.c b/src/monitor/request-handler.c
index 2d01ad0..82d598a 100644 (file)
--- a/src/monitor/request-handler.c
+++ b/src/monitor/request-handler.c
@@ -48,6 +48,17 @@ static void free_resource(gpointer key, gpointer value, gpointer user_data)
        delete_resource(res);
 }
 
+static void update_resource(gpointer key, gpointer value, gpointer user_data)
+{
+       struct resource *res = value;
+       int ret;
+
+       ret = update_resource_attrs(res);
+       if (ret < 0)
+               _E("failed to update resource attributes (name:%s,id:%d)\n",
+                                       res->name, res->id);
+}
+
 static void finalize_request_client(struct request_client *client)
 {
        if (!client)
@@ -96,6 +107,29 @@ static int handle_request_create_resource(struct request_client *client, char *a
        return res->id;
 }
 
+static int handle_request_delete_resource(struct request_client *client, char *args)
+{
+       struct resource *res;
+       int resource_id;
+
+       if (!client || !args)
+               return -ENOENT;
+
+       /**
+        * Format of REQUEST_DELETE_RESOURCE args:
+        *  - <RESOURCE_ID>
+        */
+       resource_id = atoi(args);
+
+       res = get_resource_by_id(client, resource_id);
+       if (!res)
+               return -EINVAL;
+
+       delete_resource(res);
+
+       return 0;
+}
+
 static int handle_request_update_resource(struct request_client *client, char *args)
 {
        struct resource *res;
@@ -117,17 +151,48 @@ static int handle_request_update_resource(struct request_client *client, char *a
        return update_resource_attrs(res);
 }
 
-static int handle_request_set_resource_attr(struct request_client *client, char *args)
+static int handle_request_get_resource_count(struct request_client *client, char *args)
+{
+       int resource_type;
+
+       if (!client || !args)
+               return -ENOENT;
+
+       /**
+        * Format of REQUEST_GET_RESOURCE_COUNT args:
+        *  - <RESOURCE_TYPE>
+        */
+       resource_type = atoi(args);
+
+       return get_resource_device_count(resource_type);
+}
+
+static int handle_request_update_resource_all(struct request_client *client, char *args)
+{
+       if (!client)
+               return -ENOENT;
+
+       /**
+        * Format of REQUEST_UPDATE_RESOURCE args:
+        *  - NULL
+        */
+       if (client->resource_table)
+               g_hash_table_foreach(client->resource_table, (GHFunc)update_resource, NULL);
+
+       return 0;
+}
+
+static int handle_request_set_resource_attr(struct request_client *client, char *args, int request_type)
 {
        struct resource *res;
-       int resource_id;
+       int resource_id, ret;
        u_int64_t interest_masks;
 
        if (!client || !args)
                return -ENOENT;
 
        /**
-        * Format of REQUEST_SET_RESOURCE_ATTR args:
+        * Format of REQUEST_SET_RESOURCE_ATTR and REQUEST_UNSET_RESOURCE_ATTR args:
         *  - <RESOURCE_ID:INTEREST_MASK>
         */
        if (sscanf(args, "%d:%"PRIu64, &resource_id, &interest_masks) < 2)
@@ -137,9 +202,41 @@ static int handle_request_set_resource_attr(struct request_client *client, char
        if (!res)
                return -EINVAL;
 
-       set_resource_attr_interest(res, interest_masks);
+       switch (request_type) {
+       case REQUEST_SET_RESOURCE_ATTR:
+               ret = set_resource_attr_interest(res, interest_masks);
+               break;
+       case REQUEST_UNSET_RESOURCE_ATTR:
+               ret = unset_resource_attr_interest(res, interest_masks);
+               break;
+       default:
+               return -EINVAL;
+       }
 
-       return 0;
+       return ret;
+}
+
+static int handle_request_is_resource_attr_supported(struct request_client *client, char *args)
+{
+       struct resource *res;
+       int resource_id;
+       u_int64_t attr_id;
+
+       if (!client || !args)
+               return -ENOENT;
+
+       /**
+        * Format of REQUEST_IS_RESOURCE_ATTR_SUPPORTED args:
+        *  - <RESOURCE_ID:RESOURCE_ATTR_ID>
+        */
+       if (sscanf(args, "%d:%"PRIu64"", &resource_id, &attr_id) < 2)
+               return -EINVAL;
+
+       res = get_resource_by_id(client, resource_id);
+       if (!res)
+               return -EINVAL;
+
+       return (int)is_resource_attr_supported(res, attr_id);
 }
 
 static int handle_request_set_resource_ctrl(struct request_client *client, char *args)
@@ -341,20 +438,43 @@ static void handle_request(struct request_client *client, char *buffer)
                if (ret < 0)
                        _D("failed to create resource");
                break;
+       case REQUEST_DELETE_RESOURCE:
+               ret = handle_request_delete_resource(client, args);
+               if (ret < 0)
+                       _E("failed to delete resource");
+               break;
        case REQUEST_UPDATE_RESOURCE:
                ret = handle_request_update_resource(client, args);
                if (ret < 0)
                        _D("failed to update resource");
                break;
+       case REQUEST_GET_RESOURCE_COUNT:
+               ret = handle_request_get_resource_count(client, args);
+               if (ret < 0)
+                       _E("failed to get resource count");
+               break;
+       case REQUEST_UPDATE_RESOURCE_ALL:
+               ret = handle_request_update_resource_all(client, args);
+               if (ret < 0)
+                       _E("failed to update all resources");
+               break;
        case REQUEST_SET_RESOURCE_CTRL:
                ret = handle_request_set_resource_ctrl(client, args);
                if (ret < 0)
                        _D("failed to set resource control");
                break;
        case REQUEST_SET_RESOURCE_ATTR:
-               ret = handle_request_set_resource_attr(client, args);
+       case REQUEST_UNSET_RESOURCE_ATTR:
+               ret = handle_request_set_resource_attr(client, args, request_type);
+               if (ret < 0)
+                       _E("failed to %s attr interest",
+                               request_type == REQUEST_SET_RESOURCE_ATTR
+                               ? "set" : "unset");
+               break;
+       case REQUEST_IS_RESOURCE_ATTR_SUPPORTED:
+               ret = handle_request_is_resource_attr_supported(client, args);
                if (ret < 0)
-                       _D("failed to set attr interest");
+                       _E("failed to check whether attr is supported or not");
                break;
        case REQUEST_GET_VALUE_INT:
                {