networklayer_tcp.c 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520
  1. /*
  2. * This work is licensed under a Creative Commons CCZero 1.0 Universal License.
  3. * See http://creativecommons.org/publicdomain/zero/1.0/ for more information.
  4. */
  5. #include <stdlib.h> // malloc, free
  6. #ifdef _WIN32
  7. #include <malloc.h>
  8. #include <winsock2.h>
  9. #include <sys/types.h>
  10. #include <windows.h>
  11. #include <ws2tcpip.h>
  12. #define CLOSESOCKET(S) closesocket(S)
  13. #else
  14. #include <sys/select.h>
  15. #include <netinet/in.h>
  16. #include <sys/socketvar.h>
  17. #include <sys/ioctl.h>
  18. #include <unistd.h> // read, write, close
  19. #include <arpa/inet.h>
  20. #define CLOSESOCKET(S) close(S)
  21. #endif
  22. #include <stdio.h>
  23. #include <errno.h> // errno, EINTR
  24. #include <fcntl.h> // fcntl
  25. #include "networklayer_tcp.h" // UA_MULTITHREADING is defined in here
  26. #ifdef UA_MULTITHREADING
  27. #include <urcu/uatomic.h>
  28. #endif
  29. /* Forwarded as a (UA_Connection) and used for callbacks back into the
  30. networklayer */
  31. typedef struct {
  32. UA_Connection connection;
  33. UA_Int32 sockfd;
  34. void *layer;
  35. } TCPConnection;
  36. /***************************/
  37. /* Server NetworkLayer TCP */
  38. /***************************/
  39. #define MAXBACKLOG 100
  40. /* Internal mapping of sockets to connections */
  41. typedef struct {
  42. TCPConnection *connection;
  43. #ifdef _WIN32
  44. UA_UInt32 sockfd;
  45. #else
  46. UA_Int32 sockfd;
  47. #endif
  48. } ConnectionLink;
  49. typedef struct {
  50. UA_ConnectionConfig conf;
  51. fd_set fdset;
  52. #ifdef _WIN32
  53. UA_UInt32 serversockfd;
  54. UA_UInt32 highestfd;
  55. #else
  56. UA_Int32 serversockfd;
  57. UA_Int32 highestfd;
  58. #endif
  59. UA_UInt16 conLinksSize;
  60. ConnectionLink *conLinks;
  61. UA_UInt32 port;
  62. /* We remove the connection links only in the main thread. Attach
  63. to-be-deleted links with atomic operations */
  64. struct deleteLink {
  65. #ifdef _WIN32
  66. UA_UInt32 sockfd;
  67. #else
  68. UA_Int32 sockfd;
  69. #endif
  70. struct deleteLink *next;
  71. } *deleteLinkList;
  72. } ServerNetworkLayerTCP;
  73. static UA_StatusCode setNonBlocking(int sockid) {
  74. #ifdef _WIN32
  75. u_long iMode = 1;
  76. if(ioctlsocket(sockid, FIONBIO, &iMode) != NO_ERROR)
  77. return UA_STATUSCODE_BADINTERNALERROR;
  78. #else
  79. int opts = fcntl(sockid,F_GETFL);
  80. if(opts < 0 || fcntl(sockid,F_SETFL,opts|O_NONBLOCK) < 0)
  81. return UA_STATUSCODE_BADINTERNALERROR;
  82. #endif
  83. return UA_STATUSCODE_GOOD;
  84. }
  85. static void freeConnectionCallback(UA_Server *server, TCPConnection *connection) {
  86. free(connection);
  87. }
  88. // after every select, reset the set of sockets we want to listen on
  89. static void setFDSet(ServerNetworkLayerTCP *layer) {
  90. FD_ZERO(&layer->fdset);
  91. FD_SET(layer->serversockfd, &layer->fdset);
  92. layer->highestfd = layer->serversockfd;
  93. for(UA_Int32 i=0;i<layer->conLinksSize;i++) {
  94. FD_SET(layer->conLinks[i].sockfd, &layer->fdset);
  95. if(layer->conLinks[i].sockfd > layer->highestfd)
  96. layer->highestfd = layer->conLinks[i].sockfd;
  97. }
  98. }
  99. // the callbacks are thread-safe if UA_MULTITHREADING is defined
  100. void closeConnection(TCPConnection *handle);
  101. void writeCallback(TCPConnection *handle, UA_ByteStringArray gather_buf);
  102. static UA_StatusCode ServerNetworkLayerTCP_add(ServerNetworkLayerTCP *layer, UA_Int32 newsockfd) {
  103. setNonBlocking(newsockfd);
  104. TCPConnection *c = malloc(sizeof(TCPConnection));
  105. if(!c)
  106. return UA_STATUSCODE_BADINTERNALERROR;
  107. c->sockfd = newsockfd;
  108. c->layer = layer;
  109. c->connection.state = UA_CONNECTION_OPENING;
  110. c->connection.localConf = layer->conf;
  111. c->connection.channel = UA_NULL;
  112. c->connection.close = (void (*)(void*))closeConnection;
  113. c->connection.write = (void (*)(void*, UA_ByteStringArray))writeCallback;
  114. layer->conLinks = realloc(layer->conLinks, sizeof(ConnectionLink)*(layer->conLinksSize+1));
  115. if(!layer->conLinks) {
  116. free(c);
  117. return UA_STATUSCODE_BADINTERNALERROR;
  118. }
  119. layer->conLinks[layer->conLinksSize].connection = c;
  120. layer->conLinks[layer->conLinksSize].sockfd = newsockfd;
  121. layer->conLinksSize++;
  122. return UA_STATUSCODE_GOOD;
  123. }
  124. // Takes the linked list of closed connections and returns the work for the server loop
  125. static UA_UInt32 batchDeleteLinks(ServerNetworkLayerTCP *layer, UA_WorkItem **returnWork) {
  126. UA_WorkItem *work = malloc(sizeof(UA_WorkItem)*layer->conLinksSize);
  127. if (!work) {
  128. *returnWork = NULL;
  129. return 0;
  130. }
  131. #ifdef UA_MULTITHREADING
  132. struct deleteLink *d = uatomic_xchg(&layer->deleteLinkList, UA_NULL);
  133. #else
  134. struct deleteLink *d = layer->deleteLinkList;
  135. layer->deleteLinkList = UA_NULL;
  136. #endif
  137. UA_UInt32 count = 0;
  138. while(d) {
  139. UA_Int32 i;
  140. for(i = 0;i<layer->conLinksSize;i++) {
  141. if(layer->conLinks[i].sockfd == d->sockfd)
  142. break;
  143. }
  144. if(i < layer->conLinksSize) {
  145. TCPConnection *c = layer->conLinks[i].connection;
  146. layer->conLinksSize--;
  147. layer->conLinks[i] = layer->conLinks[layer->conLinksSize];
  148. work[count] = (UA_WorkItem)
  149. {.type = UA_WORKITEMTYPE_DELAYEDMETHODCALL,
  150. .work.methodCall = {.data = c,
  151. .method = (void (*)(UA_Server*,void*))freeConnectionCallback} };
  152. }
  153. struct deleteLink *oldd = d;
  154. d = d->next;
  155. free(oldd);
  156. count++;
  157. }
  158. *returnWork = work;
  159. return count;
  160. }
  161. #ifdef UA_MULTITHREADING
  162. void closeConnection(TCPConnection *handle) {
  163. if(uatomic_xchg(&handle->connection.state, UA_CONNECTION_CLOSING) == UA_CONNECTION_CLOSING)
  164. return;
  165. UA_Connection_detachSecureChannel(&handle->connection);
  166. shutdown(handle->sockfd,2);
  167. CLOSESOCKET(handle->sockfd);
  168. // Remove the link later in the main thread
  169. struct deleteLink *d = malloc(sizeof(struct deleteLink));
  170. d->sockfd = handle->sockfd;
  171. while(1) {
  172. d->next = handle->layer->deleteLinkList;
  173. if(uatomic_cmpxchg(&handle->layer->deleteLinkList, d->next, d) == d->next)
  174. break;
  175. }
  176. }
  177. #else
  178. void closeConnection(TCPConnection *handle) {
  179. struct deleteLink *d = malloc(sizeof(struct deleteLink));
  180. if(!d)
  181. return;
  182. if(handle->connection.state == UA_CONNECTION_CLOSING)
  183. return;
  184. handle->connection.state = UA_CONNECTION_CLOSING;
  185. UA_Connection_detachSecureChannel(&handle->connection);
  186. shutdown(handle->sockfd,2);
  187. CLOSESOCKET(handle->sockfd);
  188. // Remove the link later in the main thread
  189. d->sockfd = handle->sockfd;
  190. ServerNetworkLayerTCP *layer = (ServerNetworkLayerTCP*)handle->layer;
  191. d->next = layer->deleteLinkList;
  192. layer->deleteLinkList = d;
  193. }
  194. #endif
  195. /** Accesses only the sockfd in the handle. Can be run from parallel threads. */
  196. void writeCallback(TCPConnection *handle, UA_ByteStringArray gather_buf) {
  197. UA_UInt32 total_len = 0, nWritten = 0;
  198. #ifdef _WIN32
  199. LPWSABUF buf = _alloca(gather_buf.stringsSize * sizeof(WSABUF));
  200. int result = 0;
  201. for(UA_UInt32 i = 0; i<gather_buf.stringsSize; i++) {
  202. buf[i].buf = (char*)gather_buf.strings[i].data;
  203. buf[i].len = gather_buf.strings[i].length;
  204. total_len += gather_buf.strings[i].length;
  205. }
  206. while(nWritten < total_len) {
  207. UA_UInt32 n = 0;
  208. do {
  209. result = WSASend(handle->sockfd, buf, gather_buf.stringsSize ,
  210. (LPDWORD)&n, 0, NULL, NULL);
  211. if(result != 0)
  212. printf("Error WSASend, code: %d \n", WSAGetLastError());
  213. } while(errno == EINTR);
  214. nWritten += n;
  215. }
  216. #else
  217. struct iovec iov[gather_buf.stringsSize];
  218. for(UA_UInt32 i=0;i<gather_buf.stringsSize;i++) {
  219. iov[i] = (struct iovec) {.iov_base = gather_buf.strings[i].data,
  220. .iov_len = gather_buf.strings[i].length};
  221. total_len += gather_buf.strings[i].length;
  222. }
  223. struct msghdr message = {.msg_name = NULL, .msg_namelen = 0, .msg_iov = iov,
  224. .msg_iovlen = gather_buf.stringsSize, .msg_control = NULL,
  225. .msg_controllen = 0, .msg_flags = 0};
  226. while (nWritten < total_len) {
  227. UA_Int32 n = 0;
  228. do {
  229. n = sendmsg(handle->sockfd, &message, 0);
  230. } while (n == -1L && errno == EINTR);
  231. nWritten += n;
  232. }
  233. #endif
  234. }
  235. static UA_StatusCode ServerNetworkLayerTCP_start(ServerNetworkLayerTCP *layer) {
  236. #ifdef _WIN32
  237. WORD wVersionRequested;
  238. WSADATA wsaData;
  239. wVersionRequested = MAKEWORD(2, 2);
  240. WSAStartup(wVersionRequested, &wsaData);
  241. if((layer->serversockfd = socket(PF_INET, SOCK_STREAM,0)) == INVALID_SOCKET) {
  242. printf("ERROR opening socket, code: %d\n", WSAGetLastError());
  243. return UA_STATUSCODE_BADINTERNALERROR;
  244. }
  245. #else
  246. if((layer->serversockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
  247. perror("ERROR opening socket");
  248. return UA_STATUSCODE_BADINTERNALERROR;
  249. }
  250. #endif
  251. const struct sockaddr_in serv_addr = {
  252. .sin_family = AF_INET, .sin_addr.s_addr = INADDR_ANY,
  253. .sin_port = htons(layer->port), .sin_zero = {0}};
  254. int optval = 1;
  255. if(setsockopt(layer->serversockfd, SOL_SOCKET,
  256. SO_REUSEADDR, (const char *)&optval,
  257. sizeof(optval)) == -1) {
  258. perror("setsockopt");
  259. CLOSESOCKET(layer->serversockfd);
  260. return UA_STATUSCODE_BADINTERNALERROR;
  261. }
  262. if(bind(layer->serversockfd, (const struct sockaddr *)&serv_addr,
  263. sizeof(serv_addr)) < 0) {
  264. perror("binding");
  265. CLOSESOCKET(layer->serversockfd);
  266. return UA_STATUSCODE_BADINTERNALERROR;
  267. }
  268. setNonBlocking(layer->serversockfd);
  269. listen(layer->serversockfd, MAXBACKLOG);
  270. printf("Listening for TCP connections on %s:%d\n",
  271. inet_ntoa(serv_addr.sin_addr),
  272. ntohs(serv_addr.sin_port));
  273. return UA_STATUSCODE_GOOD;
  274. }
  275. static UA_Int32 ServerNetworkLayerTCP_getWork(ServerNetworkLayerTCP *layer, UA_WorkItem **workItems,
  276. UA_UInt16 timeout) {
  277. UA_WorkItem *items = UA_NULL;
  278. UA_Int32 itemsCount = batchDeleteLinks(layer, &items);
  279. setFDSet(layer);
  280. struct timeval tmptv = {0, timeout};
  281. UA_Int32 resultsize = select(layer->highestfd+1, &layer->fdset, NULL, NULL, &tmptv);
  282. if(resultsize < 0) {
  283. *workItems = items;
  284. return itemsCount;
  285. }
  286. // accept new connections (can only be a single one)
  287. if(FD_ISSET(layer->serversockfd,&layer->fdset)) {
  288. resultsize--;
  289. struct sockaddr_in cli_addr;
  290. socklen_t cli_len = sizeof(cli_addr);
  291. int newsockfd = accept(layer->serversockfd, (struct sockaddr *) &cli_addr, &cli_len);
  292. if (newsockfd >= 0)
  293. ServerNetworkLayerTCP_add(layer, newsockfd);
  294. }
  295. items = realloc(items, sizeof(UA_WorkItem)*(itemsCount+resultsize));
  296. // read from established sockets
  297. UA_Int32 j = itemsCount;
  298. UA_ByteString buf = { -1, NULL};
  299. for(UA_Int32 i=0;i<layer->conLinksSize && j<itemsCount+resultsize;i++) {
  300. if(!(FD_ISSET(layer->conLinks[i].sockfd, &layer->fdset)))
  301. continue;
  302. if(!buf.data) {
  303. buf.data = malloc(sizeof(UA_Byte) * layer->conf.recvBufferSize);
  304. if(!buf.data)
  305. break;
  306. }
  307. #ifdef _WIN32
  308. buf.length = recv(layer->conLinks[i].sockfd, (char *)buf.data,
  309. layer->conf.recvBufferSize, 0);
  310. #else
  311. buf.length = read(layer->conLinks[i].sockfd, buf.data, layer->conf.recvBufferSize);
  312. #endif
  313. if (buf.length <= 0) {
  314. closeConnection(layer->conLinks[i].connection); // work is returned in the next iteration
  315. } else {
  316. items[j].type = UA_WORKITEMTYPE_BINARYNETWORKMESSAGE;
  317. items[j].work.binaryNetworkMessage.message = buf;
  318. items[j].work.binaryNetworkMessage.connection = &layer->conLinks[i].connection->connection;
  319. buf.data = NULL;
  320. j++;
  321. }
  322. }
  323. if(buf.data)
  324. free(buf.data);
  325. if(j == 0) {
  326. free(items);
  327. *workItems = NULL;
  328. } else
  329. *workItems = items;
  330. return j;
  331. }
  332. static UA_Int32 ServerNetworkLayerTCP_stop(ServerNetworkLayerTCP * layer, UA_WorkItem **workItems) {
  333. for(UA_Int32 index = 0;index < layer->conLinksSize;index++)
  334. closeConnection(layer->conLinks[index].connection);
  335. #ifdef _WIN32
  336. WSACleanup();
  337. #endif
  338. return batchDeleteLinks(layer, workItems);
  339. }
  340. static void ServerNetworkLayerTCP_delete(ServerNetworkLayerTCP *layer) {
  341. free(layer->conLinks);
  342. free(layer);
  343. }
  344. UA_ServerNetworkLayer ServerNetworkLayerTCP_new(UA_ConnectionConfig conf, UA_UInt32 port) {
  345. ServerNetworkLayerTCP *tcplayer = malloc(sizeof(ServerNetworkLayerTCP));
  346. tcplayer->conf = conf;
  347. tcplayer->conLinksSize = 0;
  348. tcplayer->conLinks = NULL;
  349. tcplayer->port = port;
  350. tcplayer->deleteLinkList = UA_NULL;
  351. UA_ServerNetworkLayer nl;
  352. nl.nlHandle = tcplayer;
  353. nl.start = (UA_StatusCode (*)(void*))ServerNetworkLayerTCP_start;
  354. nl.getWork = (UA_Int32 (*)(void*, UA_WorkItem**, UA_UInt16))ServerNetworkLayerTCP_getWork;
  355. nl.stop = (UA_Int32 (*)(void*, UA_WorkItem**))ServerNetworkLayerTCP_stop;
  356. nl.free = (void (*)(void*))ServerNetworkLayerTCP_delete;
  357. return nl;
  358. }
  359. /***************************/
  360. /* Client NetworkLayer TCP */
  361. /***************************/
  362. static UA_StatusCode ClientNetworkLayerTCP_connect(const UA_String endpointUrl, void **resultHandle) {
  363. if(endpointUrl.length < 11 || endpointUrl.length >= 512) {
  364. printf("server url size invalid");
  365. return UA_STATUSCODE_BADINTERNALERROR;
  366. }
  367. if(strncmp((char*)endpointUrl.data, "opc.tcp://", 10) != 0) {
  368. printf("server url does not begin with opc.tcp://");
  369. return UA_STATUSCODE_BADINTERNALERROR;
  370. }
  371. UA_UInt16 portpos = 9;
  372. UA_UInt16 port = 0;
  373. for(;portpos < endpointUrl.length; portpos++) {
  374. if(endpointUrl.data[portpos] == ':') {
  375. port = atoi((char*)&endpointUrl.data[portpos+1]);
  376. break;
  377. }
  378. }
  379. if(port == 0) {
  380. printf("port invalid");
  381. return UA_STATUSCODE_BADINTERNALERROR;
  382. }
  383. char hostname[512];
  384. for(int i=10; i < portpos; i++)
  385. hostname[i-10] = endpointUrl.data[i];
  386. hostname[portpos-10] = 0;
  387. UA_Int32 *sock = UA_Int32_new();
  388. if(!sock)
  389. return UA_STATUSCODE_BADOUTOFMEMORY;
  390. if((*sock = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
  391. free(sock);
  392. printf("Could not create socket");
  393. return UA_STATUSCODE_BADINTERNALERROR;
  394. }
  395. struct sockaddr_in server;
  396. server.sin_addr.s_addr = inet_addr(hostname);
  397. server.sin_family = AF_INET;
  398. server.sin_port = port;
  399. if(connect(*sock, (struct sockaddr *) &server, sizeof(server)) < 0) {
  400. free(sock);
  401. printf("Connect failed.");
  402. return UA_STATUSCODE_BADINTERNALERROR;
  403. }
  404. if(setNonBlocking(*sock) != UA_STATUSCODE_GOOD) {
  405. free(sock);
  406. printf("Could not switch to nonblocking.");
  407. return UA_STATUSCODE_BADINTERNALERROR;
  408. }
  409. *resultHandle = sock;
  410. return UA_STATUSCODE_GOOD;
  411. }
  412. static void ClientNetworkLayerTCP_disconnect(UA_Int32 *handle) {
  413. close(*handle);
  414. free(handle);
  415. }
  416. static UA_StatusCode ClientNetworkLayerTCP_send(UA_Int32 *handle, UA_ByteStringArray gather_buf) {
  417. struct iovec iov[gather_buf.stringsSize];
  418. int total_len = 0;
  419. for(UA_UInt32 i=0;i<gather_buf.stringsSize;i++) {
  420. iov[i] = (struct iovec) {.iov_base = gather_buf.strings[i].data,
  421. .iov_len = gather_buf.strings[i].length};
  422. total_len += gather_buf.strings[i].length;
  423. }
  424. struct msghdr message = {.msg_name = NULL, .msg_namelen = 0, .msg_iov = iov,
  425. .msg_iovlen = gather_buf.stringsSize, .msg_control = NULL,
  426. .msg_controllen = 0, .msg_flags = 0};
  427. int nWritten = 0;
  428. while (nWritten < total_len) {
  429. int n = sendmsg(*handle, &message, 0);
  430. if(n <= -1)
  431. return UA_STATUSCODE_BADINTERNALERROR;
  432. nWritten += n;
  433. }
  434. return UA_STATUSCODE_GOOD;
  435. }
  436. static UA_StatusCode ClientNetworkLayerTCP_awaitResponse(UA_Int32 *handle, UA_ByteString *response,
  437. UA_UInt32 timeout) {
  438. fd_set read_fds;
  439. FD_ZERO(&read_fds);
  440. struct timeval tmptv = {0, timeout};
  441. int ret = select(*handle+1, &read_fds, NULL, NULL, &tmptv);
  442. if(ret <= -1)
  443. return UA_STATUSCODE_BADINTERNALERROR;
  444. if(ret == 0)
  445. return UA_STATUSCODE_BADTIMEOUT;
  446. ret = recv(*handle, response->data, response->length, 0);
  447. if(ret <= -1)
  448. return UA_STATUSCODE_BADINTERNALERROR;
  449. if(ret == 0)
  450. return UA_STATUSCODE_BADSERVERNOTCONNECTED;
  451. response->length = ret;
  452. return UA_STATUSCODE_GOOD;
  453. }
  454. UA_ClientNetworkLayer ClientNetworkLayerTCP_new(UA_ConnectionConfig conf) {
  455. UA_ClientNetworkLayer layer;
  456. layer.connect = (UA_StatusCode (*)(const UA_String, void**)) ClientNetworkLayerTCP_connect;
  457. layer.disconnect = (void (*)(void*)) ClientNetworkLayerTCP_disconnect;
  458. layer.send = (UA_StatusCode (*)(void*, UA_ByteStringArray)) ClientNetworkLayerTCP_send;
  459. layer.awaitResponse = (UA_StatusCode (*)(void*, UA_ByteString *, UA_UInt32))ClientNetworkLayerTCP_awaitResponse;
  460. return layer;
  461. }