networklayer_tcp.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578
  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 "networklayer_tcp.h"
  6. #include <stdlib.h> // malloc, free
  7. #include <stdio.h> // snprintf
  8. #include <string.h> // memset
  9. #include <errno.h>
  10. #ifdef _WIN32
  11. # include <malloc.h>
  12. # include <winsock2.h>
  13. # include <ws2tcpip.h>
  14. # define CLOSESOCKET(S) closesocket(S)
  15. #else
  16. # include <fcntl.h>
  17. # include <sys/select.h>
  18. # include <netinet/in.h>
  19. #ifndef __CYGWIN__
  20. # include <netinet/tcp.h>
  21. #endif
  22. # include <sys/ioctl.h>
  23. # include <netdb.h> //gethostbyname for the client
  24. # include <unistd.h> // read, write, close
  25. # include <arpa/inet.h>
  26. #ifdef __QNX__
  27. #include <sys/socket.h>
  28. #endif
  29. # define CLOSESOCKET(S) close(S)
  30. #endif
  31. #ifdef UA_MULTITHREADING
  32. # include <urcu/uatomic.h>
  33. #endif
  34. #ifndef MSG_NOSIGNAL
  35. #define MSG_NOSIGNAL 0
  36. #endif
  37. /****************************/
  38. /* Generic Socket Functions */
  39. /****************************/
  40. static void
  41. socket_close(UA_Connection *connection) {
  42. connection->state = UA_CONNECTION_CLOSED;
  43. shutdown(connection->sockfd,2);
  44. CLOSESOCKET(connection->sockfd);
  45. }
  46. static UA_StatusCode
  47. socket_write(UA_Connection *connection, UA_ByteString *buf) {
  48. size_t nWritten = 0;
  49. while(buf->length > 0 && nWritten < (size_t)buf->length) {
  50. UA_Int32 n = 0;
  51. do {
  52. #ifdef _WIN32
  53. n = send((SOCKET)connection->sockfd, (const char*)buf->data, (size_t)buf->length, 0);
  54. const int last_error = WSAGetLastError();
  55. if(n < 0 && last_error != WSAEINTR && last_error != WSAEWOULDBLOCK) {
  56. connection->close(connection);
  57. socket_close(connection);
  58. UA_ByteString_deleteMembers(buf);
  59. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  60. }
  61. #else
  62. n = send(connection->sockfd, (const char*)buf->data, (size_t)buf->length, MSG_NOSIGNAL);
  63. if(n == -1L && errno != EINTR && errno != EAGAIN) {
  64. connection->close(connection);
  65. socket_close(connection);
  66. UA_ByteString_deleteMembers(buf);
  67. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  68. }
  69. #endif
  70. } while (n == -1L);
  71. nWritten += n;
  72. }
  73. UA_ByteString_deleteMembers(buf);
  74. return UA_STATUSCODE_GOOD;
  75. }
  76. static UA_StatusCode
  77. socket_recv(UA_Connection *connection, UA_ByteString *response, UA_UInt32 timeout) {
  78. response->data = malloc(connection->localConf.recvBufferSize);
  79. if(!response->data) {
  80. response->length = 0;
  81. return UA_STATUSCODE_BADOUTOFMEMORY; /* not enough memory retry */
  82. }
  83. if(timeout > 0) {
  84. /* currently, only the client uses timeouts */
  85. int timeout_usec = timeout * 1000;
  86. struct timeval tmptv = {timeout_usec / 1000000, timeout_usec % 1000000};
  87. int ret = setsockopt(connection->sockfd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tmptv, sizeof(struct timeval));
  88. if(0 != ret) {
  89. UA_ByteString_deleteMembers(response);
  90. socket_close(connection);
  91. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  92. }
  93. }
  94. int ret = recv(connection->sockfd, (char*)response->data, connection->localConf.recvBufferSize, 0);
  95. if(ret == 0) {
  96. /* server has closed the connection */
  97. UA_ByteString_deleteMembers(response);
  98. socket_close(connection);
  99. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  100. } else if(ret < 0) {
  101. UA_ByteString_deleteMembers(response);
  102. #ifdef _WIN32
  103. const int last_error = WSAGetLastError();
  104. if(last_error == WSAEINTR || last_error == WSAEWOULDBLOCK)
  105. #else
  106. if(errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
  107. #endif
  108. return UA_STATUSCODE_GOOD; /* retry */
  109. else {
  110. socket_close(connection);
  111. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  112. }
  113. }
  114. response->length = ret;
  115. return UA_STATUSCODE_GOOD;
  116. }
  117. static UA_StatusCode socket_set_nonblocking(UA_Int32 sockfd) {
  118. #ifdef _WIN32
  119. u_long iMode = 1;
  120. if(ioctlsocket(sockfd, FIONBIO, &iMode) != NO_ERROR)
  121. return UA_STATUSCODE_BADINTERNALERROR;
  122. #else
  123. int opts = fcntl(sockfd, F_GETFL);
  124. if(opts < 0 || fcntl(sockfd, F_SETFL, opts|O_NONBLOCK) < 0)
  125. return UA_STATUSCODE_BADINTERNALERROR;
  126. #endif
  127. return UA_STATUSCODE_GOOD;
  128. }
  129. static void FreeConnectionCallback(UA_Server *server, void *ptr) {
  130. UA_Connection_deleteMembers((UA_Connection*)ptr);
  131. free(ptr);
  132. }
  133. /***************************/
  134. /* Server NetworkLayer TCP */
  135. /***************************/
  136. /**
  137. * For the multithreaded mode, assume a single thread that periodically "gets work" from the network
  138. * layer. In addition, several worker threads are asynchronously calling into the callbacks of the
  139. * UA_Connection that holds a single connection.
  140. *
  141. * Creating a connection: When "GetWork" encounters a new connection, it creates a UA_Connection
  142. * with the socket information. This is added to the mappings array that links sockets to
  143. * UA_Connection structs.
  144. *
  145. * Reading data: In "GetWork", we listen on the sockets in the mappings array. If data arrives (or
  146. * the connection closes), a WorkItem is created that carries the work and a pointer to the
  147. * connection.
  148. *
  149. * Closing a connection: Closing can happen in two ways. Either it is triggered by the server in an
  150. * asynchronous callback. Or the connection is close by the client and this is detected in
  151. * "GetWork". The server needs to do some internal cleanups (close attached securechannels, etc.).
  152. * So even when a closed connection is detected in "GetWork", we trigger the server to close the
  153. * connection (with a WorkItem) and continue from the callback.
  154. *
  155. * - Server calls close-callback: We close the socket, set the connection-state to closed and add
  156. * the connection to a linked list from which it is deleted later. The connection cannot be freed
  157. * right away since other threads might still be using it.
  158. *
  159. * - GetWork: We remove the connection from the mappings array. In the non-multithreaded case, the
  160. * connection is freed. For multithreading, we return a workitem that is delayed, i.e. that is
  161. * called only after all workitems created before are finished in all threads. This workitems
  162. * contains a callback that goes through the linked list of connections to be freed.
  163. *
  164. */
  165. #define MAXBACKLOG 100
  166. typedef struct {
  167. UA_ServerNetworkLayer layer;
  168. /* config */
  169. UA_UInt32 port;
  170. UA_ConnectionConfig conf; /* todo: rename to localconf. */
  171. /* open sockets and connections */
  172. fd_set fdset;
  173. UA_Int32 serversockfd;
  174. UA_Int32 highestfd;
  175. size_t mappingsSize;
  176. struct ConnectionMapping {
  177. UA_Connection *connection;
  178. UA_Int32 sockfd;
  179. } *mappings;
  180. } ServerNetworkLayerTCP;
  181. static UA_StatusCode
  182. ServerNetworkLayerGetSendBuffer(UA_Connection *connection, size_t length, UA_ByteString *buf) {
  183. if(length > connection->remoteConf.recvBufferSize)
  184. return UA_STATUSCODE_BADCOMMUNICATIONERROR;
  185. return UA_ByteString_allocBuffer(buf, length);
  186. }
  187. static void
  188. ServerNetworkLayerReleaseSendBuffer(UA_Connection *connection, UA_ByteString *buf) {
  189. UA_ByteString_deleteMembers(buf);
  190. }
  191. static void
  192. ServerNetworkLayerReleaseRecvBuffer(UA_Connection *connection, UA_ByteString *buf) {
  193. UA_ByteString_deleteMembers(buf);
  194. }
  195. /* after every select, we need to reset the sockets we want to listen on */
  196. static void setFDSet(ServerNetworkLayerTCP *layer) {
  197. FD_ZERO(&layer->fdset);
  198. FD_SET((UA_UInt32)layer->serversockfd, &layer->fdset);
  199. layer->highestfd = layer->serversockfd;
  200. for(size_t i = 0; i < layer->mappingsSize; i++) {
  201. FD_SET((UA_UInt32)layer->mappings[i].sockfd, &layer->fdset);
  202. if(layer->mappings[i].sockfd > layer->highestfd)
  203. layer->highestfd = layer->mappings[i].sockfd;
  204. }
  205. }
  206. /* callback triggered from the server */
  207. static void ServerNetworkLayerTCP_closeConnection(UA_Connection *connection) {
  208. #ifdef UA_MULTITHREADING
  209. if(uatomic_xchg(&connection->state, UA_CONNECTION_CLOSED) == UA_CONNECTION_CLOSED)
  210. return;
  211. #else
  212. if(connection->state == UA_CONNECTION_CLOSED)
  213. return;
  214. connection->state = UA_CONNECTION_CLOSED;
  215. #endif
  216. ServerNetworkLayerTCP *layer = connection->handle;
  217. UA_LOG_INFO(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Closing the Connection %i",
  218. connection->sockfd);
  219. /* only "shutdown" here. this triggers the select, where the socket is
  220. "closed" in the mainloop */
  221. shutdown(connection->sockfd, 2);
  222. }
  223. /* call only from the single networking thread */
  224. static UA_StatusCode ServerNetworkLayerTCP_add(ServerNetworkLayerTCP *layer, UA_Int32 newsockfd) {
  225. UA_Connection *c = malloc(sizeof(UA_Connection));
  226. if(!c)
  227. return UA_STATUSCODE_BADINTERNALERROR;
  228. struct sockaddr_in addr;
  229. socklen_t addrlen = sizeof(struct sockaddr_in);
  230. getsockname(newsockfd, (struct sockaddr*)&addr, &addrlen);
  231. UA_LOG_INFO(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "New Connection %i over TCP from %s:%d",
  232. newsockfd, inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
  233. UA_Connection_init(c);
  234. c->sockfd = newsockfd;
  235. c->handle = layer;
  236. c->localConf = layer->conf;
  237. c->send = socket_write;
  238. c->close = ServerNetworkLayerTCP_closeConnection;
  239. c->getSendBuffer = ServerNetworkLayerGetSendBuffer;
  240. c->releaseSendBuffer = ServerNetworkLayerReleaseSendBuffer;
  241. c->releaseRecvBuffer = ServerNetworkLayerReleaseRecvBuffer;
  242. c->state = UA_CONNECTION_OPENING;
  243. struct ConnectionMapping *nm;
  244. nm = realloc(layer->mappings, sizeof(struct ConnectionMapping)*(layer->mappingsSize+1));
  245. if(!nm) {
  246. UA_LOG_ERROR(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "No memory for a new Connection");
  247. free(c);
  248. return UA_STATUSCODE_BADINTERNALERROR;
  249. }
  250. layer->mappings = nm;
  251. layer->mappings[layer->mappingsSize] = (struct ConnectionMapping){c, newsockfd};
  252. layer->mappingsSize++;
  253. return UA_STATUSCODE_GOOD;
  254. }
  255. static UA_StatusCode ServerNetworkLayerTCP_start(ServerNetworkLayerTCP *layer, UA_Logger logger) {
  256. layer->layer.logger = logger;
  257. #ifdef _WIN32
  258. if((layer->serversockfd = socket(PF_INET, SOCK_STREAM,0)) == (UA_Int32)INVALID_SOCKET) {
  259. UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Error opening socket, code: %d",
  260. WSAGetLastError());
  261. return UA_STATUSCODE_BADINTERNALERROR;
  262. }
  263. #else
  264. if((layer->serversockfd = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
  265. UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Error opening socket");
  266. return UA_STATUSCODE_BADINTERNALERROR;
  267. }
  268. #endif
  269. const struct sockaddr_in serv_addr =
  270. {.sin_family = AF_INET, .sin_addr.s_addr = INADDR_ANY,
  271. .sin_port = htons(layer->port), .sin_zero = {0}};
  272. int optval = 1;
  273. if(setsockopt(layer->serversockfd, SOL_SOCKET,
  274. SO_REUSEADDR, (const char *)&optval, sizeof(optval)) == -1) {
  275. UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK,
  276. "Error during setting of socket options");
  277. CLOSESOCKET(layer->serversockfd);
  278. return UA_STATUSCODE_BADINTERNALERROR;
  279. }
  280. if(bind(layer->serversockfd, (const struct sockaddr *)&serv_addr,
  281. sizeof(serv_addr)) < 0) {
  282. UA_LOG_WARNING(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "Error during socket binding");
  283. CLOSESOCKET(layer->serversockfd);
  284. return UA_STATUSCODE_BADINTERNALERROR;
  285. }
  286. socket_set_nonblocking(layer->serversockfd);
  287. listen(layer->serversockfd, MAXBACKLOG);
  288. UA_LOG_INFO(layer->layer.logger, UA_LOGCATEGORY_NETWORK, "TCP network layer listening on %.*s",
  289. layer->layer.discoveryUrl.length, layer->layer.discoveryUrl.data);
  290. return UA_STATUSCODE_GOOD;
  291. }
  292. static size_t
  293. ServerNetworkLayerTCP_getJobs(ServerNetworkLayerTCP *layer, UA_Job **jobs, UA_UInt16 timeout) {
  294. setFDSet(layer);
  295. struct timeval tmptv = {0, timeout};
  296. UA_Int32 resultsize;
  297. resultsize = select(layer->highestfd+1, &layer->fdset, NULL, NULL, &tmptv);
  298. if(resultsize < 0) {
  299. *jobs = NULL;
  300. return 0;
  301. }
  302. /* accept new connections (can only be a single one) */
  303. if(FD_ISSET(layer->serversockfd, &layer->fdset)) {
  304. resultsize--;
  305. struct sockaddr_in cli_addr;
  306. socklen_t cli_len = sizeof(cli_addr);
  307. int newsockfd = accept(layer->serversockfd, (struct sockaddr *) &cli_addr, &cli_len);
  308. int i = 1;
  309. setsockopt(newsockfd, IPPROTO_TCP, TCP_NODELAY, (void *)&i, sizeof(i));
  310. if(newsockfd >= 0) {
  311. socket_set_nonblocking(newsockfd);
  312. ServerNetworkLayerTCP_add(layer, newsockfd);
  313. }
  314. }
  315. /* alloc enough space for a cleanup-connection and free-connection job per resulted socket */
  316. if(resultsize == 0)
  317. return 0;
  318. UA_Job *js = malloc(sizeof(UA_Job) * resultsize * 2);
  319. if(!js)
  320. return 0;
  321. /* read from established sockets */
  322. size_t j = 0;
  323. UA_ByteString buf = UA_BYTESTRING_NULL;
  324. for(size_t i = 0; i < layer->mappingsSize && j < (size_t)resultsize; i++) {
  325. if(!(FD_ISSET(layer->mappings[i].sockfd, &layer->fdset)))
  326. continue;
  327. UA_StatusCode retval = socket_recv(layer->mappings[i].connection, &buf, 0);
  328. if(retval == UA_STATUSCODE_GOOD) {
  329. UA_Boolean realloced = UA_FALSE;
  330. retval = UA_Connection_completeMessages(layer->mappings[i].connection, &buf, &realloced);
  331. if(retval != UA_STATUSCODE_GOOD || buf.length == 0)
  332. continue;
  333. js[j].job.binaryMessage.connection = layer->mappings[i].connection;
  334. js[j].job.binaryMessage.message = buf;
  335. if(!realloced)
  336. js[j].type = UA_JOBTYPE_BINARYMESSAGE_NETWORKLAYER;
  337. else
  338. js[j].type = UA_JOBTYPE_BINARYMESSAGE_ALLOCATED;
  339. j++;
  340. } else if (retval == UA_STATUSCODE_BADCONNECTIONCLOSED) {
  341. UA_Connection *c = layer->mappings[i].connection;
  342. /* the socket was closed from remote */
  343. js[j].type = UA_JOBTYPE_DETACHCONNECTION;
  344. js[j].job.closeConnection = layer->mappings[i].connection;
  345. layer->mappings[i] = layer->mappings[layer->mappingsSize-1];
  346. layer->mappingsSize--;
  347. j++;
  348. js[j].type = UA_JOBTYPE_METHODCALL_DELAYED;
  349. js[j].job.methodCall.method = FreeConnectionCallback;
  350. js[j].job.methodCall.data = c;
  351. j++;
  352. }
  353. }
  354. if(j == 0) {
  355. free(js);
  356. js = NULL;
  357. }
  358. *jobs = js;
  359. return j;
  360. }
  361. static size_t
  362. ServerNetworkLayerTCP_stop(ServerNetworkLayerTCP *layer, UA_Job **jobs) {
  363. UA_LOG_INFO(layer->layer.logger, UA_LOGCATEGORY_NETWORK,
  364. "Shutting down the TCP network layer with %d open connection(s)", layer->mappingsSize);
  365. shutdown(layer->serversockfd,2);
  366. CLOSESOCKET(layer->serversockfd);
  367. UA_Job *items = malloc(sizeof(UA_Job) * layer->mappingsSize * 2);
  368. if(!items)
  369. return 0;
  370. for(size_t i = 0; i < layer->mappingsSize; i++) {
  371. socket_close(layer->mappings[i].connection);
  372. items[i*2].type = UA_JOBTYPE_DETACHCONNECTION;
  373. items[i*2].job.closeConnection = layer->mappings[i].connection;
  374. items[(i*2)+1].type = UA_JOBTYPE_METHODCALL_DELAYED;
  375. items[(i*2)+1].job.methodCall.method = FreeConnectionCallback;
  376. items[(i*2)+1].job.methodCall.data = layer->mappings[i].connection;
  377. }
  378. #ifdef _WIN32
  379. WSACleanup();
  380. #endif
  381. *jobs = items;
  382. return layer->mappingsSize*2;
  383. }
  384. /* run only when the server is stopped */
  385. static void ServerNetworkLayerTCP_deleteMembers(ServerNetworkLayerTCP *layer) {
  386. free(layer->mappings);
  387. }
  388. UA_ServerNetworkLayer * ServerNetworkLayerTCP_new(UA_ConnectionConfig conf, UA_UInt32 port) {
  389. #ifdef _WIN32
  390. WORD wVersionRequested;
  391. WSADATA wsaData;
  392. wVersionRequested = MAKEWORD(2, 2);
  393. WSAStartup(wVersionRequested, &wsaData);
  394. #endif
  395. ServerNetworkLayerTCP *layer = malloc(sizeof(ServerNetworkLayerTCP));
  396. if(!layer)
  397. return NULL;
  398. memset(layer, 0, sizeof(ServerNetworkLayerTCP));
  399. layer->conf = conf;
  400. layer->mappingsSize = 0;
  401. layer->mappings = NULL;
  402. layer->port = port;
  403. char hostname[256];
  404. if(gethostname(hostname, 255) == 0) {
  405. char discoveryUrl[256];
  406. UA_String str;
  407. #ifndef _MSC_VER
  408. str.length = snprintf(discoveryUrl, 255, "opc.tcp://%s:%d", hostname, port);
  409. #else
  410. str.length = _snprintf_s(discoveryUrl, 255, _TRUNCATE, "opc.tcp://%s:%d", hostname, port);
  411. #endif
  412. str.data = (UA_Byte*)discoveryUrl;
  413. UA_String_copy(&str, &layer->layer.discoveryUrl);
  414. }
  415. layer->layer.start = (UA_StatusCode(*)(UA_ServerNetworkLayer*,UA_Logger))ServerNetworkLayerTCP_start;
  416. layer->layer.getJobs = (size_t(*)(UA_ServerNetworkLayer*,UA_Job**,UA_UInt16))ServerNetworkLayerTCP_getJobs;
  417. layer->layer.stop = (size_t(*)(UA_ServerNetworkLayer*, UA_Job**))ServerNetworkLayerTCP_stop;
  418. layer->layer.deleteMembers = (void(*)(UA_ServerNetworkLayer*))ServerNetworkLayerTCP_deleteMembers;
  419. return &layer->layer;
  420. }
  421. /***************************/
  422. /* Client NetworkLayer TCP */
  423. /***************************/
  424. static UA_StatusCode
  425. ClientNetworkLayerGetBuffer(UA_Connection *connection, size_t length, UA_ByteString *buf) {
  426. if(length > connection->remoteConf.recvBufferSize)
  427. return UA_STATUSCODE_BADCOMMUNICATIONERROR;
  428. if(connection->state == UA_CONNECTION_CLOSED)
  429. return UA_STATUSCODE_BADCONNECTIONCLOSED;
  430. return UA_ByteString_allocBuffer(buf, connection->remoteConf.recvBufferSize);
  431. }
  432. static void
  433. ClientNetworkLayerReleaseBuffer(UA_Connection *connection, UA_ByteString *buf) {
  434. UA_ByteString_deleteMembers(buf);
  435. }
  436. static void
  437. ClientNetworkLayerClose(UA_Connection *connection) {
  438. #ifdef UA_MULTITHREADING
  439. if(uatomic_xchg(&connection->state, UA_CONNECTION_CLOSED) == UA_CONNECTION_CLOSED)
  440. return;
  441. #else
  442. if(connection->state == UA_CONNECTION_CLOSED)
  443. return;
  444. connection->state = UA_CONNECTION_CLOSED;
  445. #endif
  446. socket_close(connection);
  447. }
  448. /* we have no networklayer. instead, attach the reusable buffer to the handle */
  449. UA_Connection
  450. ClientNetworkLayerTCP_connect(UA_ConnectionConfig localConf, const char *endpointUrl, UA_Logger logger) {
  451. UA_Connection connection;
  452. UA_Connection_init(&connection);
  453. connection.localConf = localConf;
  454. //socket_set_nonblocking(connection.sockfd);
  455. connection.send = socket_write;
  456. connection.recv = socket_recv;
  457. connection.close = ClientNetworkLayerClose;
  458. connection.getSendBuffer = ClientNetworkLayerGetBuffer;
  459. connection.releaseSendBuffer = ClientNetworkLayerReleaseBuffer;
  460. connection.releaseRecvBuffer = ClientNetworkLayerReleaseBuffer;
  461. size_t urlLength = strlen(endpointUrl);
  462. if(urlLength < 11 || urlLength >= 512) {
  463. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "Server url size invalid");
  464. return connection;
  465. }
  466. if(strncmp(endpointUrl, "opc.tcp://", 10) != 0) {
  467. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "Server url does not begin with opc.tcp://");
  468. return connection;
  469. }
  470. UA_UInt16 portpos = 9;
  471. UA_UInt16 port;
  472. for(port = 0; portpos < urlLength-1; portpos++) {
  473. if(endpointUrl[portpos] == ':') {
  474. char *endPtr = NULL;
  475. unsigned long int tempulong = strtoul(&endpointUrl[portpos+1], &endPtr, 10);
  476. if (ERANGE != errno &&
  477. tempulong < UINT16_MAX &&
  478. endPtr != &endpointUrl[portpos+1])
  479. {
  480. port = (UA_UInt16)tempulong;
  481. }
  482. break;
  483. }
  484. }
  485. if(port == 0) {
  486. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "Port invalid");
  487. return connection;
  488. }
  489. char hostname[512];
  490. for(int i=10; i < portpos; i++)
  491. hostname[i-10] = endpointUrl[i];
  492. hostname[portpos-10] = 0;
  493. #ifdef _WIN32
  494. WORD wVersionRequested;
  495. WSADATA wsaData;
  496. wVersionRequested = MAKEWORD(2, 2);
  497. WSAStartup(wVersionRequested, &wsaData);
  498. if((connection.sockfd = socket(PF_INET, SOCK_STREAM,0)) == (UA_Int32)INVALID_SOCKET) {
  499. #else
  500. if((connection.sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
  501. #endif
  502. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "Could not create socket");
  503. return connection;
  504. }
  505. struct hostent *server = gethostbyname(hostname);
  506. if(!server) {
  507. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "DNS lookup of %s failed", hostname);
  508. return connection;
  509. }
  510. struct sockaddr_in server_addr;
  511. memset(&server_addr, 0, sizeof(server_addr));
  512. memcpy((char *)&server_addr.sin_addr.s_addr, (char *)server->h_addr_list[0], server->h_length);
  513. server_addr.sin_family = AF_INET;
  514. server_addr.sin_port = htons(port);
  515. connection.state = UA_CONNECTION_OPENING;
  516. if(connect(connection.sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)) < 0) {
  517. ClientNetworkLayerClose(&connection);
  518. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "Connection failed");
  519. return connection;
  520. }
  521. #ifdef SO_NOSIGPIPE
  522. int val = 1;
  523. if(setsockopt(connection.sockfd, SOL_SOCKET, SO_NOSIGPIPE, (void*)&val, sizeof(val)) < 0) {
  524. UA_LOG_WARNING((*logger), UA_LOGCATEGORY_NETWORK, "Couldn't set SO_NOSIGPIPE");
  525. return connection;
  526. }
  527. #endif
  528. return connection;
  529. }