networklayer_tcp.c 19 KB

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