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 "disc_server_stub.h"
17
18 #include "disc_serializer.h"
19 #include "discovery_service.h"
20 #include "ipc_skeleton.h"
21 #include "softbus_def.h"
22 #include "softbus_disc_server.h"
23 #include "softbus_errcode.h"
24 #include "softbus_log.h"
25 #include "softbus_permission.h"
26
ServerPublishService(IpcIo * req,IpcIo * reply)27 int32_t ServerPublishService(IpcIo *req, IpcIo *reply)
28 {
29 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "publish service ipc server pop.");
30 if (req == NULL || reply == NULL) {
31 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "%s:invalid param.", __func__);
32 return SOFTBUS_INVALID_PARAM;
33 }
34 size_t len;
35 unsigned char *capabilityData = NULL;
36 const char *pkgName = (const char*)ReadString(req, &len);
37 PublishSerializer *info = (PublishSerializer*)ReadRawData(req, sizeof(PublishSerializer));
38 if (info == NULL) {
39 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ipc pop is null.");
40 return SOFTBUS_ERR;
41 }
42 char *capability = (char*)ReadString(req, &len);
43 if (info->commonSerializer.dataLen != 0) {
44 capabilityData = (unsigned char*)ReadString(req, &len);
45 }
46 PublishInfo publishInfo = {
47 .capability = capability,
48 .capabilityData = capabilityData,
49 .dataLen = info->commonSerializer.dataLen,
50 .freq = info->commonSerializer.freq,
51 .medium = info->commonSerializer.medium,
52 .mode = info->commonSerializer.mode,
53 .publishId = info->commonSerializer.id.publishId,
54 };
55 int32_t callingUid = GetCallingUid();
56 if (!CheckDiscPermission(callingUid, pkgName)) {
57 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "publish service no permission.");
58 return SOFTBUS_PERMISSION_DENIED;
59 }
60 int32_t ret = DiscIpcPublishService(pkgName, &publishInfo);
61 if (ret != SOFTBUS_OK) {
62 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "publish service failed.");
63 return SOFTBUS_ERR;
64 }
65 return SOFTBUS_OK;
66 }
67
ServerUnPublishService(IpcIo * req,IpcIo * reply)68 int32_t ServerUnPublishService(IpcIo *req, IpcIo *reply)
69 {
70 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "unpublish service ipc server pop.");
71 size_t len;
72 const char *pkgName = (const char*)ReadString(req, &len);
73 int32_t publishId;
74 ReadInt32(req, &publishId);
75 int32_t callingUid = GetCallingUid();
76 if (!CheckDiscPermission(callingUid, pkgName)) {
77 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "publish service no permission.");
78 return SOFTBUS_PERMISSION_DENIED;
79 }
80 int32_t ret = DiscIpcUnPublishService(pkgName, publishId);
81 if (ret != SOFTBUS_OK) {
82 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "unpublish service failed.");
83 return SOFTBUS_ERR;
84 }
85 return SOFTBUS_OK;
86 }
87
ServerStartDiscovery(IpcIo * req,IpcIo * reply)88 int32_t ServerStartDiscovery(IpcIo *req, IpcIo *reply)
89 {
90 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "start discovery ipc server pop.");
91 size_t len;
92 unsigned char *capabilityData = NULL;
93 const char *pkgName = (const char *)ReadString(req, &len);
94 SubscribeSerializer *info = (SubscribeSerializer *)ReadRawData(req, sizeof(SubscribeSerializer));
95 if (info == NULL) {
96 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "ipc pop is null.");
97 return SOFTBUS_ERR;
98 }
99 char *capability = (char *)ReadString(req, &len);
100 if (info->commonSerializer.dataLen != 0) {
101 capabilityData = (unsigned char *)ReadString(req, &len);
102 }
103 SubscribeInfo subscribeInfo = {
104 .capability = capability,
105 .capabilityData = capabilityData,
106 .dataLen = info->commonSerializer.dataLen,
107 .freq = info->commonSerializer.freq,
108 .medium = info->commonSerializer.medium,
109 .mode = info->commonSerializer.mode,
110 .subscribeId = info->commonSerializer.id.subscribeId,
111 .isSameAccount = info->isSameAccount,
112 .isWakeRemote = info->isWakeRemote,
113 };
114 int32_t callingUid = GetCallingUid();
115 if (!CheckDiscPermission(callingUid, pkgName)) {
116 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "publish service no permission.");
117 return SOFTBUS_PERMISSION_DENIED;
118 }
119 int32_t ret = DiscIpcStartDiscovery(pkgName, &subscribeInfo);
120 if (ret != SOFTBUS_OK) {
121 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "start discovery failed.");
122 return SOFTBUS_ERR;
123 }
124 return SOFTBUS_OK;
125 }
126
ServerStopDiscovery(IpcIo * req,IpcIo * reply)127 int32_t ServerStopDiscovery(IpcIo *req, IpcIo *reply)
128 {
129 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_INFO, "stop discovery ipc server pop.");
130 size_t len;
131 const char *pkgName = (const char *)ReadString(req, &len);
132 int32_t subscribeId;
133 ReadInt32(req, &subscribeId);
134 int32_t callingUid = GetCallingUid();
135 if (!CheckDiscPermission(callingUid, pkgName)) {
136 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "publish service no permission.");
137 return SOFTBUS_PERMISSION_DENIED;
138 }
139 int32_t ret = DiscIpcStopDiscovery(pkgName, subscribeId);
140 if (ret != SOFTBUS_OK) {
141 SoftBusLog(SOFTBUS_LOG_COMM, SOFTBUS_LOG_ERROR, "stop discovery failed.");
142 return SOFTBUS_ERR;
143 }
144 return SOFTBUS_OK;
145 }
146