ua_services_discovery.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413
  1. #include "ua_server_internal.h"
  2. #include "ua_services.h"
  3. #ifdef UA_ENABLE_DISCOVERY
  4. #ifdef _MSC_VER
  5. # include <io.h> //access
  6. # define access _access
  7. #else
  8. # include <unistd.h> //access
  9. #endif
  10. #endif
  11. #ifdef UA_ENABLE_DISCOVERY
  12. static UA_StatusCode copyRegisteredServerToApplicationDescription(const UA_FindServersRequest *request, UA_ApplicationDescription *target, const UA_RegisteredServer* registeredServer) {
  13. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  14. UA_ApplicationDescription_init(target);
  15. retval |= UA_String_copy(&registeredServer->serverUri, &target->applicationUri);
  16. retval |= UA_String_copy(&registeredServer->productUri, &target->productUri);
  17. // if the client requests a specific locale, select the corresponding server name
  18. if (request->localeIdsSize) {
  19. UA_Boolean appNameFound = UA_FALSE;
  20. for (size_t i =0; i<request->localeIdsSize && !appNameFound; i++) {
  21. for (size_t j =0; j<registeredServer->serverNamesSize; j++) {
  22. if (UA_String_equal(&request->localeIds[i], &registeredServer->serverNames[j].locale)) {
  23. retval |= UA_LocalizedText_copy(&registeredServer->serverNames[j], &target->applicationName);
  24. appNameFound = UA_TRUE;
  25. break;
  26. }
  27. }
  28. }
  29. } else if (registeredServer->serverNamesSize){
  30. // just take the first name
  31. retval |= UA_LocalizedText_copy(&registeredServer->serverNames[0], &target->applicationName);
  32. }
  33. target->applicationType = registeredServer->serverType;
  34. retval |= UA_String_copy(&registeredServer->gatewayServerUri, &target->gatewayServerUri);
  35. // TODO where do we get the discoveryProfileUri for application data?
  36. target->discoveryUrlsSize = registeredServer->discoveryUrlsSize;
  37. if (registeredServer->discoveryUrlsSize) {
  38. target->discoveryUrls = UA_malloc(sizeof(UA_String) * registeredServer->discoveryUrlsSize);
  39. if (!target->discoveryUrls) {
  40. return UA_STATUSCODE_BADOUTOFMEMORY;
  41. }
  42. for (size_t i = 0; i<registeredServer->discoveryUrlsSize; i++) {
  43. retval |= UA_String_copy(&registeredServer->discoveryUrls[i], &target->discoveryUrls[i]);
  44. }
  45. }
  46. return retval;
  47. }
  48. #endif
  49. void Service_FindServers(UA_Server *server, UA_Session *session,
  50. const UA_FindServersRequest *request, UA_FindServersResponse *response) {
  51. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing FindServersRequest");
  52. size_t foundServersSize = 0;
  53. UA_ApplicationDescription *foundServers = NULL;
  54. UA_Boolean addSelf = UA_FALSE;
  55. // temporarily store all the pointers which we found to avoid reiterating through the list
  56. UA_RegisteredServer **foundServerFilteredPointer = NULL;
  57. #ifdef UA_ENABLE_DISCOVERY
  58. // check if client only requested a specific set of servers
  59. if (request->serverUrisSize) {
  60. foundServerFilteredPointer = UA_malloc(sizeof(UA_RegisteredServer*) * server->registeredServersSize);
  61. if(!foundServerFilteredPointer) {
  62. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  63. return;
  64. }
  65. for (size_t i=0; i<request->serverUrisSize; i++) {
  66. if (!addSelf && UA_String_equal(&request->serverUris[i], &server->config.applicationDescription.applicationUri)) {
  67. addSelf = UA_TRUE;
  68. } else {
  69. registeredServer_list_entry* current;
  70. LIST_FOREACH(current, &server->registeredServers, pointers) {
  71. if (UA_String_equal(&current->registeredServer.serverUri, &request->serverUris[i])) {
  72. foundServerFilteredPointer[foundServersSize++] = &current->registeredServer;
  73. break;
  74. }
  75. }
  76. }
  77. }
  78. if (addSelf)
  79. foundServersSize++;
  80. } else {
  81. addSelf = true;
  82. // self + registered servers
  83. foundServersSize = 1 + server->registeredServersSize;
  84. }
  85. #else
  86. if (request->serverUrisSize) {
  87. for (size_t i=0; i<request->serverUrisSize; i++) {
  88. if (UA_String_equal(&request->serverUris[i], &server->config.applicationDescription.applicationUri)) {
  89. addSelf = UA_TRUE;
  90. foundServersSize = 1;
  91. break;
  92. }
  93. }
  94. } else {
  95. addSelf = UA_TRUE;
  96. foundServersSize = 1;
  97. }
  98. #endif
  99. if(foundServersSize) {
  100. foundServers = UA_malloc(sizeof(UA_ApplicationDescription) * foundServersSize);
  101. if (!foundServers) {
  102. if (foundServerFilteredPointer)
  103. UA_free(foundServerFilteredPointer);
  104. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  105. return;
  106. }
  107. /* copy ApplicationDescription from the config */
  108. if(addSelf) {
  109. response->responseHeader.serviceResult |=
  110. UA_ApplicationDescription_copy(&server->config.applicationDescription, &foundServers[0]);
  111. if (response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
  112. UA_free(foundServers);
  113. if (foundServerFilteredPointer)
  114. UA_free(foundServerFilteredPointer);
  115. return;
  116. }
  117. /* add the discoveryUrls from the networklayers */
  118. UA_String* disc = UA_realloc(foundServers[0].discoveryUrls,
  119. sizeof(UA_String) * (foundServers[0].discoveryUrlsSize +
  120. server->config.networkLayersSize));
  121. if(!disc) {
  122. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  123. UA_free(foundServers);
  124. if (foundServerFilteredPointer)
  125. UA_free(foundServerFilteredPointer);
  126. return;
  127. }
  128. size_t existing = foundServers[0].discoveryUrlsSize;
  129. foundServers[0].discoveryUrls = disc;
  130. foundServers[0].discoveryUrlsSize += server->config.networkLayersSize;
  131. // TODO: Add nl only if discoveryUrl not already present
  132. for (size_t i = 0; i < server->config.networkLayersSize; i++) {
  133. UA_ServerNetworkLayer* nl = &server->config.networkLayers[i];
  134. UA_String_copy(&nl->discoveryUrl, &foundServers[0].discoveryUrls[existing + i]);
  135. }
  136. }
  137. #ifdef UA_ENABLE_DISCOVERY
  138. size_t currentIndex = 0;
  139. if (addSelf)
  140. currentIndex++;
  141. // add all the registered servers to the list
  142. if(foundServerFilteredPointer) {
  143. // use filtered list because client only requested specific uris
  144. // -1 because foundServersSize also includes this self server
  145. size_t iterCount = addSelf ? foundServersSize - 1 : foundServersSize;
  146. for(size_t i = 0; i < iterCount; i++) {
  147. response->responseHeader.serviceResult =
  148. copyRegisteredServerToApplicationDescription(request, &foundServers[currentIndex++],
  149. foundServerFilteredPointer[i]);
  150. if (response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
  151. UA_free(foundServers);
  152. UA_free(foundServerFilteredPointer);
  153. return;
  154. }
  155. }
  156. UA_free(foundServerFilteredPointer);
  157. foundServerFilteredPointer = NULL;
  158. } else {
  159. registeredServer_list_entry* current;
  160. LIST_FOREACH(current, &server->registeredServers, pointers) {
  161. response->responseHeader.serviceResult =
  162. copyRegisteredServerToApplicationDescription(request, &foundServers[currentIndex++],
  163. &current->registeredServer);
  164. if (response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) {
  165. UA_free(foundServers);
  166. return;
  167. }
  168. }
  169. }
  170. #endif
  171. }
  172. if (foundServerFilteredPointer)
  173. UA_free(foundServerFilteredPointer);
  174. response->servers = foundServers;
  175. response->serversSize = foundServersSize;
  176. }
  177. void Service_GetEndpoints(UA_Server *server, UA_Session *session, const UA_GetEndpointsRequest *request,
  178. UA_GetEndpointsResponse *response) {
  179. /* If the client expects to see a specific endpointurl, mirror it back. If
  180. not, clone the endpoints with the discovery url of all networklayers. */
  181. const UA_String *endpointUrl = &request->endpointUrl;
  182. if(endpointUrl->length > 0) {
  183. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing GetEndpointsRequest with endpointUrl " \
  184. UA_PRINTF_STRING_FORMAT, UA_PRINTF_STRING_DATA(*endpointUrl));
  185. } else {
  186. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing GetEndpointsRequest with an empty endpointUrl");
  187. }
  188. /* test if the supported binary profile shall be returned */
  189. #ifdef NO_ALLOCA
  190. UA_Boolean relevant_endpoints[server->endpointDescriptionsSize];
  191. #else
  192. UA_Boolean *relevant_endpoints = UA_alloca(sizeof(UA_Boolean) * server->endpointDescriptionsSize);
  193. #endif
  194. memset(relevant_endpoints, 0, sizeof(UA_Boolean) * server->endpointDescriptionsSize);
  195. size_t relevant_count = 0;
  196. if(request->profileUrisSize == 0) {
  197. for(size_t j = 0; j < server->endpointDescriptionsSize; ++j)
  198. relevant_endpoints[j] = true;
  199. relevant_count = server->endpointDescriptionsSize;
  200. } else {
  201. for(size_t j = 0; j < server->endpointDescriptionsSize; ++j) {
  202. for(size_t i = 0; i < request->profileUrisSize; ++i) {
  203. if(!UA_String_equal(&request->profileUris[i], &server->endpointDescriptions[j].transportProfileUri))
  204. continue;
  205. relevant_endpoints[j] = true;
  206. ++relevant_count;
  207. break;
  208. }
  209. }
  210. }
  211. if(relevant_count == 0) {
  212. response->endpointsSize = 0;
  213. return;
  214. }
  215. /* Clone the endpoint for each networklayer? */
  216. size_t clone_times = 1;
  217. UA_Boolean nl_endpointurl = false;
  218. if(endpointUrl->length == 0) {
  219. clone_times = server->config.networkLayersSize;
  220. nl_endpointurl = true;
  221. }
  222. response->endpoints = UA_Array_new(relevant_count * clone_times, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
  223. if(!response->endpoints) {
  224. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  225. return;
  226. }
  227. response->endpointsSize = relevant_count * clone_times;
  228. size_t k = 0;
  229. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  230. for(size_t i = 0; i < clone_times; ++i) {
  231. if(nl_endpointurl)
  232. endpointUrl = &server->config.networkLayers[i].discoveryUrl;
  233. for(size_t j = 0; j < server->endpointDescriptionsSize; ++j) {
  234. if(!relevant_endpoints[j])
  235. continue;
  236. retval |= UA_EndpointDescription_copy(&server->endpointDescriptions[j], &response->endpoints[k]);
  237. retval |= UA_String_copy(endpointUrl, &response->endpoints[k].endpointUrl);
  238. ++k;
  239. }
  240. }
  241. if(retval != UA_STATUSCODE_GOOD) {
  242. response->responseHeader.serviceResult = retval;
  243. UA_Array_delete(response->endpoints, response->endpointsSize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]);
  244. response->endpoints = NULL;
  245. response->endpointsSize = 0;
  246. return;
  247. }
  248. }
  249. #ifdef UA_ENABLE_DISCOVERY
  250. void Service_RegisterServer(UA_Server *server, UA_Session *session,
  251. const UA_RegisterServerRequest *request, UA_RegisterServerResponse *response) {
  252. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Processing RegisterServerRequest");
  253. registeredServer_list_entry *registeredServer_entry = NULL;
  254. {
  255. // find the server from the request in the registered list
  256. registeredServer_list_entry* current;
  257. LIST_FOREACH(current, &server->registeredServers, pointers) {
  258. if (UA_String_equal(&current->registeredServer.serverUri, &request->server.serverUri)) {
  259. registeredServer_entry = current;
  260. break;
  261. }
  262. }
  263. }
  264. if (!request->server.isOnline) {
  265. // server is shutting down. Remove it from the registered servers list
  266. if (!registeredServer_entry) {
  267. // server not found, show warning
  268. UA_LOG_WARNING_SESSION(server->config.logger, session, "Could not unregister server %.*s. Not registered.", (int)request->server.serverUri.length, request->server.serverUri.data);
  269. response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTFOUND;
  270. return;
  271. }
  272. // server found, remove from list
  273. LIST_REMOVE(registeredServer_entry, pointers);
  274. UA_RegisteredServer_deleteMembers(&registeredServer_entry->registeredServer);
  275. #ifndef UA_ENABLE_MULTITHREADING
  276. UA_free(registeredServer_entry);
  277. server->registeredServersSize--;
  278. #else
  279. server->registeredServersSize = uatomic_add_return(&server->registeredServersSize, -1);
  280. UA_Server_delayedFree(server, registeredServer_entry);
  281. #endif
  282. response->responseHeader.serviceResult = UA_STATUSCODE_GOOD;
  283. return;
  284. }
  285. UA_StatusCode retval = UA_STATUSCODE_GOOD;
  286. if (!registeredServer_entry) {
  287. // server not yet registered, register it by adding it to the list
  288. UA_LOG_DEBUG_SESSION(server->config.logger, session, "Registering new server: %.*s", (int)request->server.serverUri.length, request->server.serverUri.data);
  289. registeredServer_entry = UA_malloc(sizeof(registeredServer_list_entry));
  290. if(!registeredServer_entry) {
  291. response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY;
  292. return;
  293. }
  294. LIST_INSERT_HEAD(&server->registeredServers, registeredServer_entry, pointers);
  295. #ifndef UA_ENABLE_MULTITHREADING
  296. server->registeredServersSize++;
  297. #else
  298. server->registeredServersSize = uatomic_add_return(&server->registeredServersSize, 1);
  299. #endif
  300. } else {
  301. UA_RegisteredServer_deleteMembers(&registeredServer_entry->registeredServer);
  302. }
  303. // copy the data from the request into the list
  304. UA_RegisteredServer_copy(&request->server, &registeredServer_entry->registeredServer);
  305. registeredServer_entry->lastSeen = UA_DateTime_nowMonotonic();
  306. response->responseHeader.serviceResult = retval;
  307. }
  308. /**
  309. * Cleanup server registration:
  310. * If the semaphore file path is set, then it just checks the existence of the file.
  311. * When it is deleted, the registration is removed.
  312. * If there is no semaphore file, then the registration will be removed if it is older than 60 minutes.
  313. */
  314. void UA_Discovery_cleanupTimedOut(UA_Server *server, UA_DateTime nowMonotonic) {
  315. UA_DateTime timedOut = nowMonotonic;
  316. // registration is timed out if lastSeen is older than 60 minutes (default value, can be modified by user).
  317. if (server->config.discoveryCleanupTimeout) {
  318. timedOut -= server->config.discoveryCleanupTimeout*UA_SEC_TO_DATETIME;
  319. }
  320. registeredServer_list_entry* current, *temp;
  321. LIST_FOREACH_SAFE(current, &server->registeredServers, pointers, temp) {
  322. UA_Boolean semaphoreDeleted = UA_FALSE;
  323. if (current->registeredServer.semaphoreFilePath.length) {
  324. char* filePath = malloc(sizeof(char)*current->registeredServer.semaphoreFilePath.length+1);
  325. memcpy( filePath, current->registeredServer.semaphoreFilePath.data, current->registeredServer.semaphoreFilePath.length );
  326. filePath[current->registeredServer.semaphoreFilePath.length] = '\0';
  327. semaphoreDeleted = access( filePath, 0 ) == -1;
  328. free(filePath);
  329. }
  330. if (semaphoreDeleted || (server->config.discoveryCleanupTimeout && current->lastSeen < timedOut)) {
  331. if (semaphoreDeleted) {
  332. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_SERVER,
  333. "Registration of server with URI %.*s is removed because the semaphore file '%.*s' was deleted.",
  334. (int)current->registeredServer.serverUri.length, current->registeredServer.serverUri.data,
  335. (int)current->registeredServer.semaphoreFilePath.length, current->registeredServer.semaphoreFilePath.data);
  336. } else {
  337. // cppcheck-suppress unreadVariable
  338. UA_String lastStr = UA_DateTime_toString(current->lastSeen);
  339. UA_LOG_INFO(server->config.logger, UA_LOGCATEGORY_SERVER,
  340. "Registration of server with URI %.*s has timed out and is removed. Last seen: %.*s",
  341. (int)current->registeredServer.serverUri.length, current->registeredServer.serverUri.data,
  342. (int)lastStr.length, lastStr.data);
  343. UA_free(lastStr.data);
  344. }
  345. LIST_REMOVE(current, pointers);
  346. UA_RegisteredServer_deleteMembers(&current->registeredServer);
  347. #ifndef UA_ENABLE_MULTITHREADING
  348. UA_free(current);
  349. server->registeredServersSize--;
  350. #else
  351. server->registeredServersSize = uatomic_add_return(&server->registeredServersSize, -1);
  352. UA_Server_delayedFree(server, current);
  353. #endif
  354. }
  355. }
  356. }
  357. #endif