1 /*
2 * Copyright (C) 2009-2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "SocketClient"
18
19 #include <alloca.h>
20 #include <arpa/inet.h>
21 #include <errno.h>
22 #include <malloc.h>
23 #include <pthread.h>
24 #include <signal.h>
25 #include <string.h>
26 #include <sys/socket.h>
27 #include <sys/types.h>
28 #include <unistd.h>
29
30 #include <log/log.h>
31 #include <sysutils/SocketClient.h>
32
SocketClient(int socket,bool owned)33 SocketClient::SocketClient(int socket, bool owned) {
34 init(socket, owned, false);
35 }
36
SocketClient(int socket,bool owned,bool useCmdNum)37 SocketClient::SocketClient(int socket, bool owned, bool useCmdNum) {
38 init(socket, owned, useCmdNum);
39 }
40
init(int socket,bool owned,bool useCmdNum)41 void SocketClient::init(int socket, bool owned, bool useCmdNum) {
42 mSocket = socket;
43 mSocketOwned = owned;
44 mUseCmdNum = useCmdNum;
45 pthread_mutex_init(&mWriteMutex, NULL);
46 pthread_mutex_init(&mRefCountMutex, NULL);
47 mPid = -1;
48 mUid = -1;
49 mGid = -1;
50 mRefCount = 1;
51 mCmdNum = 0;
52
53 struct ucred creds;
54 socklen_t szCreds = sizeof(creds);
55 memset(&creds, 0, szCreds);
56
57 int err = getsockopt(socket, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
58 if (err == 0) {
59 mPid = creds.pid;
60 mUid = creds.uid;
61 mGid = creds.gid;
62 }
63 }
64
~SocketClient()65 SocketClient::~SocketClient() {
66 if (mSocketOwned) {
67 close(mSocket);
68 }
69 }
70
sendMsg(int code,const char * msg,bool addErrno)71 int SocketClient::sendMsg(int code, const char *msg, bool addErrno) {
72 return sendMsg(code, msg, addErrno, mUseCmdNum);
73 }
74
sendMsg(int code,const char * msg,bool addErrno,bool useCmdNum)75 int SocketClient::sendMsg(int code, const char *msg, bool addErrno, bool useCmdNum) {
76 char *buf;
77 int ret = 0;
78
79 if (addErrno) {
80 if (useCmdNum) {
81 ret = asprintf(&buf, "%d %d %s (%s)", code, getCmdNum(), msg, strerror(errno));
82 } else {
83 ret = asprintf(&buf, "%d %s (%s)", code, msg, strerror(errno));
84 }
85 } else {
86 if (useCmdNum) {
87 ret = asprintf(&buf, "%d %d %s", code, getCmdNum(), msg);
88 } else {
89 ret = asprintf(&buf, "%d %s", code, msg);
90 }
91 }
92 // Send the zero-terminated message
93 if (ret != -1) {
94 ret = sendMsg(buf);
95 free(buf);
96 }
97 return ret;
98 }
99
100 // send 3-digit code, null, binary-length, binary data
sendBinaryMsg(int code,const void * data,int len)101 int SocketClient::sendBinaryMsg(int code, const void *data, int len) {
102
103 // 4 bytes for the code & null + 4 bytes for the len
104 char buf[8];
105 // Write the code
106 snprintf(buf, 4, "%.3d", code);
107 // Write the len
108 uint32_t tmp = htonl(len);
109 memcpy(buf + 4, &tmp, sizeof(uint32_t));
110
111 struct iovec vec[2];
112 vec[0].iov_base = (void *) buf;
113 vec[0].iov_len = sizeof(buf);
114 vec[1].iov_base = (void *) data;
115 vec[1].iov_len = len;
116
117 pthread_mutex_lock(&mWriteMutex);
118 int result = sendDataLockedv(vec, (len > 0) ? 2 : 1);
119 pthread_mutex_unlock(&mWriteMutex);
120
121 return result;
122 }
123
124 // Sends the code (c-string null-terminated).
sendCode(int code)125 int SocketClient::sendCode(int code) {
126 char buf[4];
127 snprintf(buf, sizeof(buf), "%.3d", code);
128 return sendData(buf, sizeof(buf));
129 }
130
quoteArg(const char * arg)131 char *SocketClient::quoteArg(const char *arg) {
132 int len = strlen(arg);
133 char *result = (char *)malloc(len * 2 + 3);
134 char *current = result;
135 const char *end = arg + len;
136 char *oldresult;
137
138 if(result == NULL) {
139 SLOGW("malloc error (%s)", strerror(errno));
140 return NULL;
141 }
142
143 *(current++) = '"';
144 while (arg < end) {
145 switch (*arg) {
146 case '\\':
147 case '"':
148 *(current++) = '\\'; // fallthrough
149 default:
150 *(current++) = *(arg++);
151 }
152 }
153 *(current++) = '"';
154 *(current++) = '\0';
155 oldresult = result; // save pointer in case realloc fails
156 result = (char *)realloc(result, current-result);
157 return result ? result : oldresult;
158 }
159
160
sendMsg(const char * msg)161 int SocketClient::sendMsg(const char *msg) {
162 // Send the message including null character
163 if (sendData(msg, strlen(msg) + 1) != 0) {
164 SLOGW("Unable to send msg '%s'", msg);
165 return -1;
166 }
167 return 0;
168 }
169
sendData(const void * data,int len)170 int SocketClient::sendData(const void *data, int len) {
171 struct iovec vec[1];
172 vec[0].iov_base = (void *) data;
173 vec[0].iov_len = len;
174
175 pthread_mutex_lock(&mWriteMutex);
176 int rc = sendDataLockedv(vec, 1);
177 pthread_mutex_unlock(&mWriteMutex);
178
179 return rc;
180 }
181
sendDatav(struct iovec * iov,int iovcnt)182 int SocketClient::sendDatav(struct iovec *iov, int iovcnt) {
183 pthread_mutex_lock(&mWriteMutex);
184 int rc = sendDataLockedv(iov, iovcnt);
185 pthread_mutex_unlock(&mWriteMutex);
186
187 return rc;
188 }
189
sendDataLockedv(struct iovec * iov,int iovcnt)190 int SocketClient::sendDataLockedv(struct iovec *iov, int iovcnt) {
191
192 if (mSocket < 0) {
193 errno = EHOSTUNREACH;
194 return -1;
195 }
196
197 if (iovcnt <= 0) {
198 return 0;
199 }
200
201 int ret = 0;
202 int e = 0; // SLOGW and sigaction are not inert regarding errno
203 int current = 0;
204
205 struct sigaction new_action, old_action;
206 memset(&new_action, 0, sizeof(new_action));
207 new_action.sa_handler = SIG_IGN;
208 sigaction(SIGPIPE, &new_action, &old_action);
209
210 for (;;) {
211 ssize_t rc = TEMP_FAILURE_RETRY(
212 writev(mSocket, iov + current, iovcnt - current));
213
214 if (rc > 0) {
215 size_t written = rc;
216 while ((current < iovcnt) && (written >= iov[current].iov_len)) {
217 written -= iov[current].iov_len;
218 current++;
219 }
220 if (current == iovcnt) {
221 break;
222 }
223 iov[current].iov_base = (char *)iov[current].iov_base + written;
224 iov[current].iov_len -= written;
225 continue;
226 }
227
228 if (rc == 0) {
229 e = EIO;
230 SLOGW("0 length write :(");
231 } else {
232 e = errno;
233 SLOGW("write error (%s)", strerror(e));
234 }
235 ret = -1;
236 break;
237 }
238
239 sigaction(SIGPIPE, &old_action, &new_action);
240
241 if (e != 0) {
242 errno = e;
243 }
244 return ret;
245 }
246
incRef()247 void SocketClient::incRef() {
248 pthread_mutex_lock(&mRefCountMutex);
249 mRefCount++;
250 pthread_mutex_unlock(&mRefCountMutex);
251 }
252
decRef()253 bool SocketClient::decRef() {
254 bool deleteSelf = false;
255 pthread_mutex_lock(&mRefCountMutex);
256 mRefCount--;
257 if (mRefCount == 0) {
258 deleteSelf = true;
259 } else if (mRefCount < 0) {
260 SLOGE("SocketClient refcount went negative!");
261 }
262 pthread_mutex_unlock(&mRefCountMutex);
263 if (deleteSelf) {
264 delete this;
265 }
266 return deleteSelf;
267 }
268