1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
/*
* libnotification
*
* Copyright (c) 2015 Samsung Electronics Co., Ltd. All rights reserved.
*
* Contact: Kyuho Jo <kyuho.jo@samsung.com>
*
* Licensed 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.
*
*/
#define _GNU_SOURCE /* for asprintf */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <libintl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/un.h>
#include <bundle_internal.h>
#include <notification.h>
#include <notification_internal.h>
EXPORT_API int notification_wait_response(notification_h noti,
int timeout,
int *respi,
char **respc)
{
bundle *b, *bc = NULL;
pid_t tid;
const char *tid_c;
int sock_fd, msg_fd;
char *sock_path;
struct sockaddr_un sock_addr;
char msg_buffer[1024];
ssize_t msg_size;
struct timeval timeout_tv;
char *resp;
memset(msg_buffer, 0, sizeof(msg_buffer));
/* a response packet *must* have an execute option TYPE_RESPONDING
with an associated bundle.
If its bundle does not already contain a "tid" hint (which
complex applications such as xwalk may overwrite), we will
try to find the TID and set it in the bundle ourselves. */
notification_get_execute_option(noti, NOTIFICATION_EXECUTE_TYPE_RESPONDING,
NULL, &b);
if (b == NULL)
return NOTIFICATION_ERROR_INVALID_PARAMETER;
tid_c = bundle_get_val(b, "tid");
if (tid_c == NULL) {
tid = syscall(SYS_gettid);
asprintf((char **)&tid_c, "%d", tid);
bc = bundle_dup(b);
bundle_add(bc, "tid", tid_c);
notification_set_execute_option(noti, NOTIFICATION_EXECUTE_TYPE_RESPONDING,
NULL, NULL, bc);
bundle_free(bc);
notification_update(noti);
}
sock_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (sock_fd == -1)
return NOTIFICATION_ERROR_OUT_OF_MEMORY;
sock_addr.sun_family = AF_UNIX;
asprintf(&sock_path, "/tmp/.notification-%s", tid_c);
strncpy(sock_addr.sun_path, sock_path, sizeof(sock_addr.sun_path) - 1);
if (bind(sock_fd, (struct sockaddr *)&sock_addr, sizeof(sock_addr)) == -1) {
close(sock_fd);
free(sock_path);
free((char *)tid_c);
return NOTIFICATION_ERROR_OUT_OF_MEMORY;
}
if (timeout > 0) {
timeout_tv.tv_sec = timeout;
timeout_tv.tv_usec = 0;
setsockopt(sock_fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout_tv, sizeof(timeout_tv));
setsockopt(sock_fd, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout_tv, sizeof(timeout_tv));
}
listen(sock_fd, 1);
msg_fd = accept(sock_fd, NULL, 0);
do {
msg_size = read(msg_fd, msg_buffer, 1024);
} while (msg_size > 0);
resp = strtok(msg_buffer, "\n");
if (resp) {
*respi = atoi(resp);
if (respc != NULL) {
resp = strtok(NULL, "\n");
if (resp)
*respc = resp;
else
*respc = NULL;
}
} else {
*respi = 0;
if (respc != NULL)
*respc = NULL;
}
close(msg_fd);
close(sock_fd);
unlink(sock_path);
free(sock_path);
free((char *)tid_c);
return NOTIFICATION_ERROR_NONE;
}
|
