networklayer_tcp.c 19 KB

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