1/*
2* Copyright (c) 2021 Huawei Device Co., Ltd.
3* Licensed under the Apache License, Version 2.0 (the "License");
4* you may not use this file except in compliance with the License.
5* You may obtain a copy of the License at
6*
7*     http://www.apache.org/licenses/LICENSE-2.0
8*
9* Unless required by applicable law or agreed to in writing, software
10* distributed under the License is distributed on an "AS IS" BASIS,
11* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12* See the License for the specific language governing permissions and
13* limitations under the License.
14*/
15
16#include "fd_holder.h"
17#include <stdio.h>
18#include <errno.h>
19
20#include "beget_ext.h"
21#include "fd_holder_internal.h"
22#include "init_utils.h"
23#include "securec.h"
24
25static int BuildClientSocket(void)
26{
27    int sockFd;
28    sockFd = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);
29    BEGET_ERROR_CHECK(sockFd >= 0, return -1, "Failed to build socket, err = %d", errno);
30
31    struct sockaddr_un addr;
32    (void)memset_s(&addr, sizeof(addr), 0, sizeof(addr));
33    addr.sun_family = AF_UNIX;
34    int ret = strncpy_s(addr.sun_path, sizeof(addr.sun_path), INIT_HOLDER_SOCKET_PATH,
35        strlen(INIT_HOLDER_SOCKET_PATH));
36    BEGET_ERROR_CHECK(ret == 0, close(sockFd);
37        return -1, "Failed to build socket path");
38
39    socklen_t len = (socklen_t)(offsetof(struct sockaddr_un, sun_path) + strlen(addr.sun_path) + 1);
40
41    ret = connect(sockFd, (struct sockaddr *)&addr, len);
42    BEGET_ERROR_CHECK(ret >= 0, close(sockFd);
43        return -1, "Failed to connect to socket, err = %d", errno);
44    return sockFd;
45}
46
47STATIC int BuildSendData(char *buffer, size_t size, const char *serviceName, bool hold, bool poll)
48{
49    if (buffer == NULL || size == 0 || serviceName == 0) {
50        return -1;
51    }
52
53    if (!hold && poll) {
54        BEGET_LOGE("Get fd with poll set, invalid parameter");
55        return -1;
56    }
57
58    char *holdString = ACTION_HOLD;
59    if (!hold) {
60        holdString = ACTION_GET;
61    }
62    char *pollString = WITHPOLL;
63    if (!poll) {
64        pollString = WITHOUTPOLL;
65    }
66
67    if (snprintf_s(buffer, size, size - 1, "%s|%s|%s", serviceName, holdString, pollString) == -1) {
68        BEGET_LOGE("Failed to build send data");
69        return -1;
70    }
71    return 0;
72}
73
74static int ServiceSendFds(const char *serviceName, int *fds, int fdCount, bool doPoll)
75{
76    int sock = BuildClientSocket();
77    BEGET_CHECK(sock >= 0, return -1);
78
79    struct iovec iovec = {};
80    struct msghdr msghdr = {
81        .msg_iov = &iovec,
82        .msg_iovlen = 1,
83    };
84
85    char sendBuffer[MAX_FD_HOLDER_BUFFER] = {};
86    int ret = BuildSendData(sendBuffer, sizeof(sendBuffer), serviceName, true, doPoll);
87    BEGET_ERROR_CHECK(ret >= 0, close(sock);
88        return -1, "Failed to build send data");
89
90    BEGET_LOGV("Send data: [%s]", sendBuffer);
91    iovec.iov_base = sendBuffer;
92    iovec.iov_len = strlen(sendBuffer);
93
94    if (BuildControlMessage(&msghdr, fds, fdCount, true) < 0) {
95        BEGET_LOGE("Failed to build control message");
96        if (msghdr.msg_control != NULL) {
97            free(msghdr.msg_control);
98            msghdr.msg_control = NULL;
99        }
100        msghdr.msg_controllen = 0;
101        close(sock);
102        return -1;
103    }
104
105    if (TEMP_FAILURE_RETRY(sendmsg(sock, &msghdr, MSG_NOSIGNAL)) < 0) {
106        BEGET_LOGE("Failed to send fds to init, err = %d", errno);
107        if (msghdr.msg_control != NULL) {
108            free(msghdr.msg_control);
109            msghdr.msg_control = NULL;
110        }
111        msghdr.msg_controllen = 0;
112        close(sock);
113        return -1;
114    }
115    if (msghdr.msg_control != NULL) {
116        free(msghdr.msg_control);
117        msghdr.msg_control = NULL;
118    }
119    msghdr.msg_controllen = 0;
120    BEGET_LOGI("Send fds done");
121    close(sock);
122    return 0;
123}
124
125int ServiceSaveFd(const char *serviceName, int *fds, int fdCount)
126{
127    // Sanity checks
128    if (serviceName == NULL || fds == NULL ||
129        fdCount < 0 || fdCount > MAX_HOLD_FDS) {
130        BEGET_LOGE("Invalid parameters");
131        return -1;
132    }
133    return ServiceSendFds(serviceName, fds, fdCount, false);
134}
135
136int ServiceSaveFdWithPoll(const char *serviceName, int *fds, int fdCount)
137{
138    // Sanity checks
139    if (serviceName == NULL || fds == NULL ||
140        fdCount < 0 || fdCount > MAX_HOLD_FDS) {
141        BEGET_LOGE("Invalid parameters");
142        return -1;
143    }
144    return ServiceSendFds(serviceName, fds, fdCount, true);
145}
146
147int *ServiceGetFd(const char *serviceName, size_t *outfdCount)
148{
149    if (serviceName == NULL || outfdCount == NULL) {
150        BEGET_LOGE("Invalid parameters");
151        return NULL;
152    }
153
154    char path[MAX_FD_HOLDER_BUFFER] = {};
155    int ret = snprintf_s(path, MAX_FD_HOLDER_BUFFER, MAX_FD_HOLDER_BUFFER - 1, ENV_FD_HOLD_PREFIX"%s", serviceName);
156    BEGET_ERROR_CHECK(ret > 0, return NULL, "Failed snprintf_s err=%d", errno);
157    const char *value = getenv(path);
158    if (value == NULL) {
159        BEGET_LOGE("Cannot get env %s\n", path);
160        return NULL;
161    }
162
163    char fdBuffer[MAX_FD_HOLDER_BUFFER] = {};
164    ret = strncpy_s(fdBuffer, MAX_FD_HOLDER_BUFFER - 1, value, strlen(value));
165    BEGET_ERROR_CHECK(ret == 0, return NULL, "Failed strncpy_s err=%d", errno);
166    BEGET_LOGV("fds = %s", fdBuffer);
167    int fdCount = 0;
168    char **fdList = SplitStringExt(fdBuffer, " ", &fdCount, MAX_HOLD_FDS);
169    BEGET_ERROR_CHECK(fdList != NULL, return NULL, "Cannot get fd list");
170
171    int *fds = calloc((size_t)fdCount, sizeof(int));
172    BEGET_ERROR_CHECK(fds != NULL, FreeStringVector(fdList, fdCount);
173        *outfdCount = 0;
174        return NULL,
175        "Allocate memory for fd failed. err = %d", errno);
176
177    bool encounterError = false;
178    for (int i = 0; i < fdCount; i++) {
179        errno = 0;
180        fds[i] = (int)strtol(fdList[i], NULL, DECIMAL_BASE);
181        BEGET_ERROR_CHECK(errno == 0, encounterError = true;
182            break, "Failed to convert \' %s \' to fd number", fdList[i]);
183    }
184
185    if (encounterError) {
186        free(fds);
187        fds = NULL;
188        fdCount = 0;
189    }
190    *outfdCount = fdCount;
191    FreeStringVector(fdList, fdCount);
192    return fds;
193}
194