ua_network_tcp.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718
  1. /* This work is licensed under a Creative Commons CCZero 1.0 Universal License.
  2. * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. */
  3. #if defined(__MINGW32__) && (!defined(WINVER) || WINVER < 0x501)
  4. /* Assume the target is newer than Windows XP */
  5. # undef WINVER
  6. # undef _WIN32_WINDOWS
  7. # undef _WIN32_WINNT
  8. # define WINVER 0x0501
  9. # define _WIN32_WINDOWS 0x0501
  10. # define _WIN32_WINNT 0x0501
  11. #endif
  12. #include "ua_network_tcp.h"
  13. #include <stdlib.h> // malloc, free
  14. #include <stdio.h> // snprintf
  15. #include <string.h> // memset
  16. #include <errno.h>
  17. #ifdef _WIN32
  18. # ifndef __clang__
  19. # include <malloc.h>
  20. # endif
  21. /* Fix redefinition of SLIST_ENTRY on mingw winnt.h */
  22. # ifdef SLIST_ENTRY
  23. # undef SLIST_ENTRY
  24. # endif
  25. /* inet_ntoa is deprecated on MSVC but used for compatibility */
  26. # define _WINSOCK_DEPRECATED_NO_WARNINGS
  27. # include <winsock2.h>
  28. # include <ws2tcpip.h>
  29. # define CLOSESOCKET(S) closesocket((SOCKET)S)
  30. # define ssize_t int
  31. # define WIN32_INT (int)
  32. #else
  33. # define CLOSESOCKET(S) close(S)
  34. # define SOCKET int
  35. # define WIN32_INT
  36. # include <arpa/inet.h>
  37. # include <netinet/in.h>
  38. # include <sys/select.h>
  39. # include <sys/ioctl.h>
  40. # include <fcntl.h>
  41. # include <unistd.h> // read, write, close
  42. # include <netdb.h>
  43. # ifdef __QNX__
  44. # include <sys/socket.h>
  45. # endif
  46. #if defined(__unix__) || (defined(__APPLE__) && defined(__MACH__))
  47. # include <sys/param.h>
  48. # if defined(BSD)
  49. # include<sys/socket.h>
  50. # endif
  51. #endif
  52. # ifndef __CYGWIN__
  53. # include <netinet/tcp.h>
  54. # endif
  55. #endif
  56. /* unsigned int for windows and workaround to a glibc bug */
  57. #if defined(_WIN32) || defined(__OpenBSD__) || \
  58. (defined(__GNU_LIBRARY__) && (__GNU_LIBRARY__ <= 6) && \
  59. (__GLIBC__ <= 2) && (__GLIBC_MINOR__ < 16))
  60. # define UA_fd_set(fd, fds) FD_SET((unsigned int)fd, fds)
  61. # define UA_fd_isset(fd, fds) FD_ISSET((unsigned int)fd, fds)
  62. #else
  63. # define UA_fd_set(fd, fds) FD_SET(fd, fds)
  64. # define UA_fd_isset(fd, fds) FD_ISSET(fd, fds)
  65. #endif
  66. #ifdef UA_ENABLE_MULTITHREADING
  67. # include <urcu/uatomic.h>
  68. #endif
  69. #ifdef _WIN32
  70. #define errno__ WSAGetLastError()
  71. # define INTERRUPTED WSAEINTR
  72. # define WOULDBLOCK WSAEWOULDBLOCK
  73. # define AGAIN WSAEWOULDBLOCK
  74. #else
  75. # define errno__ errno
  76. # define INTERRUPTED EINTR
  77. # define WOULDBLOCK EWOULDBLOCK
  78. # define AGAIN EAGAIN
  79. #endif
  80. /****************************/
  81. /* Generic Socket Functions */
  82. /****************************/
  83. static void
  84. socket_close(UA_Connection *connection) {
  85. connection->state = UA_CONNECTION_CLOSED;
  86. shutdown((SOCKET)connection->sockfd,2);
  87. CLOSESOCKET(connection->sockfd);
  88. }
  89. static UA_StatusCode
  90. socket_write(UA_Connection *connection, UA_ByteString *buf) {
  91. size_t nWritten = 0;
  92. do {
  93. ssize_t n = 0;
  94. do {
  95. /* If the OS throws EMSGSIZE, force a smaller packet size:
  96. * size_t bytes_to_send = buf->length - nWritten > 1024 ? 1024 : buf->length - nWritten; */
  97. size_t bytes_to_send = buf->length - nWritten;
  98. n = send((SOCKET)connection->sockfd, (const char*)buf->data + nWritten,
  99. WIN32_INT bytes_to_send, 0);
  100. if(n < 0 && errno__ != INTERRUPTED && errno__ != AGAIN) {
  101. connection->close(connection);
  102. socket_close(connection);
  103. UA_ByteString_deleteMembers(buf);
  104. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  105. }
  106. } while(n < 0);
  107. nWritten += (size_t)n;
  108. } while(nWritten < buf->length);
  109. UA_ByteString_deleteMembers(buf);
  110. return UA_STATUSCODE_GOOD;
  111. }
  112. static UA_StatusCode
  113. socket_recv(UA_Connection *connection, UA_ByteString *response, UA_UInt32 timeout) {
  114. response->data = malloc(connection->localConf.recvBufferSize);
  115. if(!response->data) {
  116. response->length = 0;
  117. return UA_STATUSCODE_BADOUTOFMEMORY; /* not enough memory retry */
  118. }
  119. if(timeout > 0) {
  120. /* currently, only the client uses timeouts */
  121. #ifndef _WIN32
  122. UA_UInt32 timeout_usec = timeout * 1000;
  123. # ifdef __APPLE__
  124. struct timeval tmptv = {(long int)(timeout_usec / 1000000), timeout_usec % 1000000};
  125. # else
  126. struct timeval tmptv = {(long int)(timeout_usec / 1000000), (long int)(timeout_usec % 1000000)};
  127. # endif
  128. int ret = setsockopt(connection->sockfd, SOL_SOCKET, SO_RCVTIMEO,
  129. (const char *)&tmptv, sizeof(struct timeval));
  130. #else
  131. DWORD timeout_dw = timeout;
  132. int ret = setsockopt(connection->sockfd, SOL_SOCKET, SO_RCVTIMEO,
  133. (const char*)&timeout_dw, sizeof(DWORD));
  134. #endif
  135. if(0 != ret) {
  136. UA_ByteString_deleteMembers(response);
  137. socket_close(connection);
  138. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  139. }
  140. }
  141. #ifdef __CYGWIN__
  142. /* Workaround for https://cygwin.com/ml/cygwin/2013-07/msg00107.html */
  143. ssize_t ret;
  144. if(timeout > 0) {
  145. fd_set fdset;
  146. FD_ZERO(&fdset);
  147. UA_fd_set(connection->sockfd, &fdset);
  148. UA_UInt32 timeout_usec = timeout * 1000;
  149. struct timeval tmptv = {(long int)(timeout_usec / 1000000),
  150. (long int)(timeout_usec % 1000000)};
  151. int retval = select(connection->sockfd+1, &fdset, NULL, NULL, &tmptv);
  152. if(retval && UA_fd_isset(connection->sockfd, &fdset)) {
  153. ret = recv(connection->sockfd, (char*)response->data,
  154. connection->localConf.recvBufferSize, 0);
  155. } else {
  156. ret = 0;
  157. }
  158. } else {
  159. ret = recv(connection->sockfd, (char*)response->data,
  160. connection->localConf.recvBufferSize, 0);
  161. }
  162. #else
  163. ssize_t ret = recv(connection->sockfd, (char*)response->data,
  164. connection->localConf.recvBufferSize, 0);
  165. #endif
  166. /* server has closed the connection */
  167. if(ret == 0) {
  168. UA_ByteString_deleteMembers(response);
  169. socket_close(connection);
  170. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  171. }
  172. /* error case */
  173. if(ret < 0) {
  174. UA_ByteString_deleteMembers(response);
  175. if(errno__ == INTERRUPTED || (timeout > 0) ?
  176. false : (errno__ == EAGAIN || errno__ == WOULDBLOCK))
  177. return UA_STATUSCODE_GOOD; /* statuscode_good but no data -> retry */
  178. socket_close(connection);
  179. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  180. }
  181. /* default case */
  182. response->length = (size_t)ret;
  183. return UA_STATUSCODE_GOOD;
  184. }
  185. static UA_StatusCode socket_set_nonblocking(SOCKET sockfd) {
  186. #ifdef _WIN32
  187. u_long iMode = 1;
  188. if(ioctlsocket(sockfd, FIONBIO, &iMode) != NO_ERROR)
  189. return UA_STATUSCODE_BADINTERNALERROR;
  190. #else
  191. int opts = fcntl(sockfd, F_GETFL);
  192. if(opts < 0 || fcntl(sockfd, F_SETFL, opts|O_NONBLOCK) < 0)
  193. return UA_STATUSCODE_BADINTERNALERROR;
  194. #endif
  195. return UA_STATUSCODE_GOOD;
  196. }
  197. static void FreeConnectionCallback(UA_Server *server, void *ptr) {
  198. UA_Connection_deleteMembers((UA_Connection*)ptr);
  199. free(ptr);
  200. }
  201. /***************************/
  202. /* Server NetworkLayer TCP */
  203. /***************************/
  204. /**
  205. * For the multithreaded mode, assume a single thread that periodically "gets
  206. * work" from the network layer. In addition, several worker threads are
  207. * asynchronously calling into the callbacks of the UA_Connection that holds a
  208. * single connection.
  209. *
  210. * Creating a connection: When "GetJobs" encounters a new connection, it creates
  211. * a UA_Connection with the socket information. This is added to the mappings
  212. * array that links sockets to UA_Connection structs.
  213. *
  214. * Reading data: In "GetJobs", we listen on the sockets in the mappings array.
  215. * If data arrives (or the connection closes), a WorkItem is created that
  216. * carries the work and a pointer to the connection.
  217. *
  218. * Closing a connection: Closing can happen in two ways. Either it is triggered
  219. * by the server in an asynchronous callback. Or the connection is close by the
  220. * client and this is detected in "GetJobs". The server needs to do some
  221. * internal cleanups (close attached securechannels, etc.). So even when a
  222. * closed connection is detected in "GetJobs", we trigger the server to close
  223. * the connection (with a WorkItem) and continue from the callback.
  224. *
  225. * - Server calls close-callback: We close the socket, set the connection-state
  226. * to closed and add the connection to a linked list from which it is deleted
  227. * later. The connection cannot be freed right away since other threads might
  228. * still be using it.
  229. *
  230. * - GetJobs: We remove the connection from the mappings array. In the
  231. * non-multithreaded case, the connection is freed. For multithreading, we
  232. * return a workitem that is delayed, i.e. that is called only after all
  233. * workitems created before are finished in all threads. This workitems
  234. * contains a callback that goes through the linked list of connections to be
  235. * freed. */
  236. #define MAXBACKLOG 100
  237. typedef struct {
  238. UA_ConnectionConfig conf;
  239. UA_UInt16 port;
  240. UA_Logger logger; // Set during start
  241. /* open sockets and connections */
  242. UA_Int32 serversockfd;
  243. size_t mappingsSize;
  244. struct ConnectionMapping {
  245. UA_Connection *connection;
  246. UA_Int32 sockfd;
  247. } *mappings;
  248. } ServerNetworkLayerTCP;
  249. static UA_StatusCode
  250. ServerNetworkLayerGetSendBuffer(UA_Connection *connection, size_t length, UA_ByteString *buf) {
  251. if(length > connection->remoteConf.recvBufferSize)
  252. return UA_STATUSCODE_BADCOMMUNICATIONERROR;
  253. return UA_ByteString_allocBuffer(buf, length);
  254. }
  255. static void
  256. ServerNetworkLayerReleaseSendBuffer(UA_Connection *connection, UA_ByteString *buf) {
  257. UA_ByteString_deleteMembers(buf);
  258. }
  259. static void
  260. ServerNetworkLayerReleaseRecvBuffer(UA_Connection *connection, UA_ByteString *buf) {
  261. UA_ByteString_deleteMembers(buf);
  262. }
  263. /* after every select, we need to reset the sockets we want to listen on */
  264. static UA_Int32
  265. setFDSet(ServerNetworkLayerTCP *layer, fd_set *fdset) {
  266. FD_ZERO(fdset);
  267. UA_fd_set(layer->serversockfd, fdset);
  268. UA_Int32 highestfd = layer->serversockfd;
  269. for(size_t i = 0; i < layer->mappingsSize; ++i) {
  270. UA_fd_set(layer->mappings[i].sockfd, fdset);
  271. if(layer->mappings[i].sockfd > highestfd)
  272. highestfd = layer->mappings[i].sockfd;
  273. }
  274. return highestfd;
  275. }
  276. /* callback triggered from the server */
  277. static void
  278. ServerNetworkLayerTCP_closeConnection(UA_Connection *connection) {
  279. #ifdef UA_ENABLE_MULTITHREADING
  280. if(uatomic_xchg(&connection->state, UA_CONNECTION_CLOSED) == UA_CONNECTION_CLOSED)
  281. return;
  282. #else
  283. if(connection->state == UA_CONNECTION_CLOSED)
  284. return;
  285. connection->state = UA_CONNECTION_CLOSED;
  286. #endif
  287. #if UA_LOGLEVEL <= 300
  288. //cppcheck-suppress unreadVariable
  289. ServerNetworkLayerTCP *layer = connection->handle;
  290. UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK,
  291. "Connection %i | Force closing the connection",
  292. connection->sockfd);
  293. #endif
  294. /* only "shutdown" here. this triggers the select, where the socket is
  295. "closed" in the mainloop */
  296. shutdown(connection->sockfd, 2);
  297. }
  298. /* call only from the single networking thread */
  299. static UA_StatusCode
  300. ServerNetworkLayerTCP_add(ServerNetworkLayerTCP *layer, UA_Int32 newsockfd) {
  301. UA_Connection *c = malloc(sizeof(UA_Connection));
  302. if(!c)
  303. return UA_STATUSCODE_BADINTERNALERROR;
  304. struct sockaddr_in addr;
  305. socklen_t addrlen = sizeof(struct sockaddr_in);
  306. int res = getpeername(newsockfd, (struct sockaddr*)&addr, &addrlen);
  307. if(res == 0) {
  308. UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK,
  309. "Connection %i | New connection over TCP from %s:%d",
  310. newsockfd, inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
  311. } else {
  312. UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK,
  313. "Connection %i | New connection over TCP, "
  314. "getpeername failed with errno %i", newsockfd, errno);
  315. }
  316. memset(c, 0, sizeof(UA_Connection));
  317. c->sockfd = newsockfd;
  318. c->handle = layer;
  319. c->localConf = layer->conf;
  320. c->remoteConf = layer->conf;
  321. c->send = socket_write;
  322. c->close = ServerNetworkLayerTCP_closeConnection;
  323. c->getSendBuffer = ServerNetworkLayerGetSendBuffer;
  324. c->releaseSendBuffer = ServerNetworkLayerReleaseSendBuffer;
  325. c->releaseRecvBuffer = ServerNetworkLayerReleaseRecvBuffer;
  326. c->state = UA_CONNECTION_OPENING;
  327. struct ConnectionMapping *nm;
  328. nm = realloc(layer->mappings, sizeof(struct ConnectionMapping)*(layer->mappingsSize+1));
  329. if(!nm) {
  330. UA_LOG_ERROR(layer->logger, UA_LOGCATEGORY_NETWORK, "No memory for a new Connection");
  331. free(c);
  332. return UA_STATUSCODE_BADINTERNALERROR;
  333. }
  334. layer->mappings = nm;
  335. layer->mappings[layer->mappingsSize].connection = c;
  336. layer->mappings[layer->mappingsSize].sockfd = newsockfd;
  337. ++layer->mappingsSize;
  338. return UA_STATUSCODE_GOOD;
  339. }
  340. static UA_StatusCode
  341. ServerNetworkLayerTCP_start(UA_ServerNetworkLayer *nl, UA_Logger logger) {
  342. ServerNetworkLayerTCP *layer = nl->handle;
  343. layer->logger = logger;
  344. /* get the discovery url from the hostname */
  345. UA_String du = UA_STRING_NULL;
  346. char hostname[256];
  347. if(gethostname(hostname, 255) == 0) {
  348. char discoveryUrl[256];
  349. #ifndef _MSC_VER
  350. du.length = (size_t)snprintf(discoveryUrl, 255, "opc.tcp://%s:%d",
  351. hostname, layer->port);
  352. #else
  353. du.length = (size_t)_snprintf_s(discoveryUrl, 255, _TRUNCATE,
  354. "opc.tcp://%s:%d", hostname, layer->port);
  355. #endif
  356. du.data = (UA_Byte*)discoveryUrl;
  357. }
  358. UA_String_copy(&du, &nl->discoveryUrl);
  359. /* Create the server socket */
  360. SOCKET newsock = socket(PF_INET, SOCK_STREAM, 0);
  361. #ifdef _WIN32
  362. if(newsock == INVALID_SOCKET)
  363. #else
  364. if(newsock < 0)
  365. #endif
  366. {
  367. UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK,
  368. "Error opening the server socket");
  369. return UA_STATUSCODE_BADINTERNALERROR;
  370. }
  371. /* Set socket options */
  372. int optval = 1;
  373. if(setsockopt(newsock, SOL_SOCKET, SO_REUSEADDR,
  374. (const char *)&optval, sizeof(optval)) == -1 ||
  375. socket_set_nonblocking(newsock) != UA_STATUSCODE_GOOD) {
  376. UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK,
  377. "Error during setting of server socket options");
  378. CLOSESOCKET(newsock);
  379. return UA_STATUSCODE_BADINTERNALERROR;
  380. }
  381. /* Bind socket to address */
  382. const struct sockaddr_in serv_addr = {
  383. .sin_family = AF_INET, .sin_addr.s_addr = INADDR_ANY,
  384. .sin_port = htons(layer->port), .sin_zero = {0}};
  385. if(bind(newsock, (const struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
  386. UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK,
  387. "Error during binding of the server socket");
  388. CLOSESOCKET(newsock);
  389. return UA_STATUSCODE_BADINTERNALERROR;
  390. }
  391. /* Start listening */
  392. if(listen(newsock, MAXBACKLOG) < 0) {
  393. UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK,
  394. "Error listening on server socket");
  395. CLOSESOCKET(newsock);
  396. return UA_STATUSCODE_BADINTERNALERROR;
  397. }
  398. layer->serversockfd = (UA_Int32)newsock; /* cast on win32 */
  399. UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK,
  400. "TCP network layer listening on %.*s",
  401. nl->discoveryUrl.length, nl->discoveryUrl.data);
  402. return UA_STATUSCODE_GOOD;
  403. }
  404. static size_t
  405. ServerNetworkLayerTCP_getJobs(UA_ServerNetworkLayer *nl, UA_Job **jobs, UA_UInt16 timeout) {
  406. ServerNetworkLayerTCP *layer = nl->handle;
  407. fd_set fdset, errset;
  408. UA_Int32 highestfd = setFDSet(layer, &fdset);
  409. setFDSet(layer, &errset);
  410. struct timeval tmptv = {0, timeout * 1000};
  411. UA_Int32 resultsize = select(highestfd+1, &fdset, NULL, &errset, &tmptv);
  412. if(resultsize <= 0) {
  413. *jobs = NULL;
  414. return 0;
  415. }
  416. /* accept new connections (can only be a single one) */
  417. if(UA_fd_isset(layer->serversockfd, &fdset)) {
  418. --resultsize;
  419. SOCKET newsockfd = accept((SOCKET)layer->serversockfd, NULL, NULL);
  420. #ifdef _WIN32
  421. if(newsockfd != INVALID_SOCKET)
  422. #else
  423. if(newsockfd >= 0)
  424. #endif
  425. {
  426. socket_set_nonblocking(newsockfd);
  427. /* Send messages directly and do wait to merge packets (disable
  428. Nagle's algorithm) */
  429. int i = 1;
  430. setsockopt(newsockfd, IPPROTO_TCP, TCP_NODELAY, (void *)&i, sizeof(i));
  431. ServerNetworkLayerTCP_add(layer, (UA_Int32)newsockfd);
  432. }
  433. }
  434. /* alloc enough space for a cleanup-connection and free-connection job per
  435. resulted socket */
  436. if(resultsize == 0)
  437. return 0;
  438. UA_Job *js = malloc(sizeof(UA_Job) * (size_t)resultsize * 2);
  439. if(!js)
  440. return 0;
  441. /* read from established sockets */
  442. size_t j = 0;
  443. UA_ByteString buf = UA_BYTESTRING_NULL;
  444. for(size_t i = 0; i < layer->mappingsSize && j < (size_t)resultsize; ++i) {
  445. if(!UA_fd_isset(layer->mappings[i].sockfd, &errset) &&
  446. !UA_fd_isset(layer->mappings[i].sockfd, &fdset))
  447. continue;
  448. UA_StatusCode retval = socket_recv(layer->mappings[i].connection, &buf, 0);
  449. if(retval == UA_STATUSCODE_GOOD) {
  450. js[j].job.binaryMessage.connection = layer->mappings[i].connection;
  451. js[j].job.binaryMessage.message = buf;
  452. js[j].type = UA_JOBTYPE_BINARYMESSAGE_NETWORKLAYER;
  453. ++j;
  454. } else if (retval == UA_STATUSCODE_BADCONNECTIONCLOSED) {
  455. UA_Connection *c = layer->mappings[i].connection;
  456. UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK,
  457. "Connection %i | Connection closed from remote", c->sockfd);
  458. /* the socket was closed from remote */
  459. js[j].type = UA_JOBTYPE_DETACHCONNECTION;
  460. js[j].job.closeConnection = layer->mappings[i].connection;
  461. layer->mappings[i] = layer->mappings[layer->mappingsSize-1];
  462. --layer->mappingsSize;
  463. ++j;
  464. js[j].type = UA_JOBTYPE_METHODCALL_DELAYED;
  465. js[j].job.methodCall.method = FreeConnectionCallback;
  466. js[j].job.methodCall.data = c;
  467. ++j;
  468. }
  469. }
  470. if(j == 0) {
  471. free(js);
  472. js = NULL;
  473. }
  474. *jobs = js;
  475. return j;
  476. }
  477. static size_t
  478. ServerNetworkLayerTCP_stop(UA_ServerNetworkLayer *nl, UA_Job **jobs) {
  479. ServerNetworkLayerTCP *layer = nl->handle;
  480. UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK,
  481. "Shutting down the TCP network layer with %d open connection(s)",
  482. layer->mappingsSize);
  483. shutdown((SOCKET)layer->serversockfd,2);
  484. CLOSESOCKET(layer->serversockfd);
  485. UA_Job *items = malloc(sizeof(UA_Job) * layer->mappingsSize * 2);
  486. if(!items)
  487. return 0;
  488. for(size_t i = 0; i < layer->mappingsSize; ++i) {
  489. socket_close(layer->mappings[i].connection);
  490. items[i*2].type = UA_JOBTYPE_DETACHCONNECTION;
  491. items[i*2].job.closeConnection = layer->mappings[i].connection;
  492. items[(i*2)+1].type = UA_JOBTYPE_METHODCALL_DELAYED;
  493. items[(i*2)+1].job.methodCall.method = FreeConnectionCallback;
  494. items[(i*2)+1].job.methodCall.data = layer->mappings[i].connection;
  495. }
  496. #ifdef _WIN32
  497. WSACleanup();
  498. #endif
  499. *jobs = items;
  500. return layer->mappingsSize*2;
  501. }
  502. /* run only when the server is stopped */
  503. static void ServerNetworkLayerTCP_deleteMembers(UA_ServerNetworkLayer *nl) {
  504. ServerNetworkLayerTCP *layer = nl->handle;
  505. free(layer->mappings);
  506. free(layer);
  507. UA_String_deleteMembers(&nl->discoveryUrl);
  508. }
  509. UA_ServerNetworkLayer
  510. UA_ServerNetworkLayerTCP(UA_ConnectionConfig conf, UA_UInt16 port) {
  511. #ifdef _WIN32
  512. WORD wVersionRequested;
  513. WSADATA wsaData;
  514. wVersionRequested = MAKEWORD(2, 2);
  515. WSAStartup(wVersionRequested, &wsaData);
  516. #endif
  517. UA_ServerNetworkLayer nl;
  518. memset(&nl, 0, sizeof(UA_ServerNetworkLayer));
  519. ServerNetworkLayerTCP *layer = calloc(1,sizeof(ServerNetworkLayerTCP));
  520. if(!layer)
  521. return nl;
  522. layer->conf = conf;
  523. layer->port = port;
  524. nl.handle = layer;
  525. nl.start = ServerNetworkLayerTCP_start;
  526. nl.getJobs = ServerNetworkLayerTCP_getJobs;
  527. nl.stop = ServerNetworkLayerTCP_stop;
  528. nl.deleteMembers = ServerNetworkLayerTCP_deleteMembers;
  529. return nl;
  530. }
  531. /***************************/
  532. /* Client NetworkLayer TCP */
  533. /***************************/
  534. static UA_StatusCode
  535. ClientNetworkLayerGetBuffer(UA_Connection *connection, size_t length, UA_ByteString *buf) {
  536. if(length > connection->remoteConf.recvBufferSize)
  537. return UA_STATUSCODE_BADCOMMUNICATIONERROR;
  538. if(connection->state == UA_CONNECTION_CLOSED)
  539. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  540. return UA_ByteString_allocBuffer(buf, connection->remoteConf.recvBufferSize);
  541. }
  542. static void
  543. ClientNetworkLayerReleaseBuffer(UA_Connection *connection, UA_ByteString *buf) {
  544. UA_ByteString_deleteMembers(buf);
  545. }
  546. static void
  547. ClientNetworkLayerClose(UA_Connection *connection) {
  548. #ifdef UA_ENABLE_MULTITHREADING
  549. if(uatomic_xchg(&connection->state, UA_CONNECTION_CLOSED) == UA_CONNECTION_CLOSED)
  550. return;
  551. #else
  552. if(connection->state == UA_CONNECTION_CLOSED)
  553. return;
  554. connection->state = UA_CONNECTION_CLOSED;
  555. #endif
  556. socket_close(connection);
  557. }
  558. /* we have no networklayer. instead, attach the reusable buffer to the handle */
  559. UA_Connection
  560. UA_ClientConnectionTCP(UA_ConnectionConfig conf, const char *endpointUrl,
  561. UA_Logger logger) {
  562. #ifdef _WIN32
  563. WORD wVersionRequested;
  564. WSADATA wsaData;
  565. wVersionRequested = MAKEWORD(2, 2);
  566. WSAStartup(wVersionRequested, &wsaData);
  567. #endif
  568. UA_Connection connection;
  569. memset(&connection, 0, sizeof(UA_Connection));
  570. connection.state = UA_CONNECTION_OPENING;
  571. connection.localConf = conf;
  572. connection.remoteConf = conf;
  573. connection.send = socket_write;
  574. connection.recv = socket_recv;
  575. connection.close = ClientNetworkLayerClose;
  576. connection.getSendBuffer = ClientNetworkLayerGetBuffer;
  577. connection.releaseSendBuffer = ClientNetworkLayerReleaseBuffer;
  578. connection.releaseRecvBuffer = ClientNetworkLayerReleaseBuffer;
  579. char hostname[512];
  580. UA_UInt16 port = 0;
  581. const char *path = NULL;
  582. UA_StatusCode parse_retval = UA_EndpointUrl_split(endpointUrl, hostname, &port, &path);
  583. if(parse_retval != UA_STATUSCODE_GOOD) {
  584. if(parse_retval == UA_STATUSCODE_BADOUTOFRANGE)
  585. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK,
  586. "Server url is invalid: %s", endpointUrl);
  587. else if(parse_retval == UA_STATUSCODE_BADATTRIBUTEIDINVALID)
  588. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK,
  589. "Server url does not begin with 'opc.tcp://' '%s'", endpointUrl);
  590. return connection;
  591. }
  592. if(port == 0) {
  593. port = 4840;
  594. UA_LOG_INFO(logger, UA_LOGCATEGORY_NETWORK,
  595. "No port defined, using standard port %d", port);
  596. }
  597. struct addrinfo hints, *server;
  598. memset(&hints, 0, sizeof(hints));
  599. hints.ai_socktype = SOCK_STREAM;
  600. hints.ai_family = AF_INET;
  601. char portStr[6];
  602. #ifndef _MSC_VER
  603. snprintf(portStr, 6, "%d", port);
  604. #else
  605. _snprintf_s(portStr, 6, _TRUNCATE, "%d", port);
  606. #endif
  607. int error = getaddrinfo(hostname, portStr, &hints, &server);
  608. if(error != 0 || !server) {
  609. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK,
  610. "DNS lookup of %s failed with error %s",
  611. hostname, gai_strerror(error));
  612. return connection;
  613. }
  614. /* Get a socket */
  615. SOCKET clientsockfd = socket(server->ai_family, server->ai_socktype, server->ai_protocol);
  616. #ifdef _WIN32
  617. if(clientsockfd == INVALID_SOCKET) {
  618. #else
  619. if(clientsockfd < 0) {
  620. #endif
  621. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, "Could not create client socket");
  622. freeaddrinfo(server);
  623. return connection;
  624. }
  625. /* Connect to the server */
  626. connection.sockfd = (UA_Int32)clientsockfd; /* cast for win32 */
  627. error = connect(clientsockfd, server->ai_addr, WIN32_INT server->ai_addrlen);
  628. freeaddrinfo(server);
  629. if(error < 0) {
  630. ClientNetworkLayerClose(&connection);
  631. #ifdef _WIN32
  632. wchar_t *s = NULL;
  633. FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
  634. NULL, WSAGetLastError(),
  635. MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
  636. (LPWSTR)&s, 0, NULL);
  637. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, "Connection to %s failed. Error: %d: %S", endpointUrl, WSAGetLastError(), s);
  638. LocalFree(s);
  639. #else
  640. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, "Connection to %s failed. Error: %d: %s", endpointUrl, errno, strerror(errno));
  641. #endif
  642. return connection;
  643. }
  644. #ifdef SO_NOSIGPIPE
  645. int val = 1;
  646. if(setsockopt(connection.sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&val, sizeof(val)) < 0) {
  647. UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, "Couldn't set SO_NOSIGPIPE");
  648. return connection;
  649. }
  650. #endif
  651. return connection;
  652. }