networklayer_tcp.c 20 KB

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