sal_socket.c 31 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122
  1. /*
  2. * Copyright (c) 2006-2018, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2018-05-23 ChenYong First version
  9. * 2018-11-12 ChenYong Add TLS support
  10. */
  11. #include <rtthread.h>
  12. #include <rthw.h>
  13. #include <sys/time.h>
  14. #include <sal_socket.h>
  15. #include <sal_netdb.h>
  16. #ifdef SAL_USING_TLS
  17. #include <sal_tls.h>
  18. #endif
  19. #include <sal.h>
  20. #include <netdev.h>
  21. #include <ipc/workqueue.h>
  22. /* check system workqueue stack size */
  23. #if RT_SYSTEM_WORKQUEUE_STACKSIZE < 1536
  24. #error "The system workqueue stack size must more than 1536 bytes"
  25. #endif
  26. #define DBG_TAG "sal.skt"
  27. #define DBG_LVL DBG_INFO
  28. #include <rtdbg.h>
  29. #define SOCKET_TABLE_STEP_LEN 4
  30. /* the socket table used to dynamic allocate sockets */
  31. struct sal_socket_table
  32. {
  33. uint32_t max_socket;
  34. struct sal_socket **sockets;
  35. };
  36. #ifdef SAL_USING_TLS
  37. /* The global TLS protocol options */
  38. static struct sal_proto_tls *proto_tls;
  39. #endif
  40. /* The global socket table */
  41. static struct sal_socket_table socket_table;
  42. static struct rt_mutex sal_core_lock;
  43. static rt_bool_t init_ok = RT_FALSE;
  44. #define IS_SOCKET_PROTO_TLS(sock) (((sock)->protocol == PROTOCOL_TLS) || \
  45. ((sock)->protocol == PROTOCOL_DTLS))
  46. #define SAL_SOCKOPS_PROTO_TLS_VALID(sock, name) (proto_tls && (proto_tls->ops->name) && IS_SOCKET_PROTO_TLS(sock))
  47. #define SAL_SOCKOPT_PROTO_TLS_EXEC(sock, name, optval, optlen) \
  48. do { \
  49. if (SAL_SOCKOPS_PROTO_TLS_VALID(sock, name)){ \
  50. return proto_tls->ops->name((sock)->user_data_tls, (optval), (optlen)); \
  51. } \
  52. }while(0) \
  53. #define SAL_SOCKET_OBJ_GET(sock, socket) \
  54. do { \
  55. (sock) = sal_get_socket(socket); \
  56. if ((sock) == RT_NULL) { \
  57. return -1; \
  58. } \
  59. }while(0) \
  60. #define SAL_NETDEV_IS_UP(netdev) \
  61. do { \
  62. if (!netdev_is_up(netdev)) { \
  63. return -1; \
  64. } \
  65. }while(0) \
  66. #define SAL_NETDEV_SOCKETOPS_VALID(netdev, pf, ops) \
  67. do { \
  68. (pf) = (struct sal_proto_family *) netdev->sal_user_data; \
  69. if ((pf)->skt_ops->ops == RT_NULL){ \
  70. return -1; \
  71. } \
  72. }while(0) \
  73. #define SAL_NETDEV_NETDBOPS_VALID(netdev, pf, ops) \
  74. ((netdev) && netdev_is_up(netdev) && \
  75. ((pf) = (struct sal_proto_family *) (netdev)->sal_user_data) != RT_NULL && \
  76. (pf)->netdb_ops->ops) \
  77. /**
  78. * SAL (Socket Abstraction Layer) initialize.
  79. *
  80. * @return result 0: initialize success
  81. * -1: initialize failed
  82. */
  83. int sal_init(void)
  84. {
  85. int cn;
  86. if (init_ok)
  87. {
  88. LOG_D("Socket Abstraction Layer is already initialized.");
  89. return 0;
  90. }
  91. /* init sal socket table */
  92. cn = SOCKET_TABLE_STEP_LEN < SAL_SOCKETS_NUM ? SOCKET_TABLE_STEP_LEN : SAL_SOCKETS_NUM;
  93. socket_table.max_socket = cn;
  94. socket_table.sockets = rt_calloc(1, cn * sizeof(struct sal_socket *));
  95. if (socket_table.sockets == RT_NULL)
  96. {
  97. LOG_E("No memory for socket table.\n");
  98. return -1;
  99. }
  100. /* create sal socket lock */
  101. rt_mutex_init(&sal_core_lock, "sal_lock", RT_IPC_FLAG_FIFO);
  102. LOG_I("Socket Abstraction Layer initialize success.");
  103. init_ok = RT_TRUE;
  104. return 0;
  105. }
  106. INIT_COMPONENT_EXPORT(sal_init);
  107. /* check SAL network interface device internet status */
  108. static void check_netdev_internet_up_work(struct rt_work *work, void *work_data)
  109. {
  110. #define SAL_INTERNET_VERSION 0x00
  111. #define SAL_INTERNET_BUFF_LEN 12
  112. #define SAL_INTERNET_TIMEOUT (2)
  113. #define SAL_INTERNET_HOST "link.rt-thread.org"
  114. #define SAL_INTERNET_PORT 8101
  115. #define SAL_INTERNET_MONTH_LEN 4
  116. #define SAL_INTERNET_DATE_LEN 16
  117. int index, sockfd = -1, result = 0;
  118. struct sockaddr_in server_addr;
  119. struct hostent *host;
  120. struct timeval timeout;
  121. struct netdev *netdev = (struct netdev *)work_data;
  122. socklen_t addr_len = sizeof(struct sockaddr_in);
  123. char send_data[SAL_INTERNET_BUFF_LEN], recv_data = 0;
  124. struct rt_delayed_work *delay_work = (struct rt_delayed_work *)work;
  125. const char month[][SAL_INTERNET_MONTH_LEN] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
  126. char date[SAL_INTERNET_DATE_LEN];
  127. int moth_num = 0;
  128. struct sal_proto_family *pf = (struct sal_proto_family *) netdev->sal_user_data;
  129. const struct sal_socket_ops *skt_ops;
  130. if (work)
  131. {
  132. rt_free(delay_work);
  133. }
  134. /* get network interface socket operations */
  135. if (pf == RT_NULL || pf->skt_ops == RT_NULL)
  136. {
  137. result = -RT_ERROR;
  138. goto __exit;
  139. }
  140. host = (struct hostent *) pf->netdb_ops->gethostbyname(SAL_INTERNET_HOST);
  141. if (host == RT_NULL)
  142. {
  143. result = -RT_ERROR;
  144. goto __exit;
  145. }
  146. skt_ops = pf->skt_ops;
  147. if ((sockfd = skt_ops->socket(AF_INET, SOCK_DGRAM, 0)) < 0)
  148. {
  149. result = -RT_ERROR;
  150. goto __exit;
  151. }
  152. server_addr.sin_family = AF_INET;
  153. server_addr.sin_port = htons(SAL_INTERNET_PORT);
  154. server_addr.sin_addr = *((struct in_addr *)host->h_addr);
  155. rt_memset(&(server_addr.sin_zero), 0, sizeof(server_addr.sin_zero));
  156. timeout.tv_sec = SAL_INTERNET_TIMEOUT;
  157. timeout.tv_usec = 0;
  158. /* set receive and send timeout */
  159. skt_ops->setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (void *) &timeout, sizeof(timeout));
  160. skt_ops->setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, (void *) &timeout, sizeof(timeout));
  161. /* get build moth value*/
  162. rt_memset(date, 0x00, SAL_INTERNET_DATE_LEN);
  163. rt_snprintf(date, SAL_INTERNET_DATE_LEN, "%s", __DATE__);
  164. for (index = 0; index < sizeof(month) / SAL_INTERNET_MONTH_LEN; index++)
  165. {
  166. if (rt_memcmp(date, month[index], SAL_INTERNET_MONTH_LEN - 1) == 0)
  167. {
  168. moth_num = index + 1;
  169. break;
  170. }
  171. }
  172. /* not find build month */
  173. if (moth_num == 0 || moth_num > sizeof(month) / SAL_INTERNET_MONTH_LEN)
  174. {
  175. result = -RT_ERROR;
  176. goto __exit;
  177. }
  178. rt_memset(send_data, 0x00, SAL_INTERNET_BUFF_LEN);
  179. send_data[0] = SAL_INTERNET_VERSION;
  180. for (index = 0; index < netdev->hwaddr_len; index++)
  181. {
  182. send_data[index + 1] = netdev->hwaddr[index] + moth_num;
  183. }
  184. send_data[9] = RT_VERSION;
  185. send_data[10] = RT_SUBVERSION;
  186. send_data[11] = RT_REVISION;
  187. skt_ops->sendto(sockfd, send_data, SAL_INTERNET_BUFF_LEN, 0,
  188. (struct sockaddr *)&server_addr, sizeof(struct sockaddr));
  189. result = skt_ops->recvfrom(sockfd, &recv_data, sizeof(recv_data), 0, (struct sockaddr *)&server_addr, &addr_len);
  190. if (result < 0)
  191. {
  192. goto __exit;
  193. }
  194. if (recv_data == RT_FALSE)
  195. {
  196. result = -RT_ERROR;
  197. goto __exit;
  198. }
  199. __exit:
  200. if (result > 0)
  201. {
  202. LOG_D("Set network interface device(%s) internet status up.", netdev->name);
  203. netdev->flags |= NETDEV_FLAG_INTERNET_UP;
  204. }
  205. else
  206. {
  207. LOG_D("Set network interface device(%s) internet status down.", netdev->name);
  208. netdev->flags &= ~NETDEV_FLAG_INTERNET_UP;
  209. }
  210. if (sockfd >= 0)
  211. {
  212. skt_ops->closesocket(sockfd);
  213. }
  214. }
  215. /**
  216. * This function will check SAL network interface device internet status.
  217. *
  218. * @param netdev the network interface device to check
  219. */
  220. int sal_check_netdev_internet_up(struct netdev *netdev)
  221. {
  222. /* workqueue for network connect */
  223. struct rt_delayed_work *net_work = RT_NULL;
  224. RT_ASSERT(netdev);
  225. net_work = (struct rt_delayed_work *)rt_calloc(1, sizeof(struct rt_delayed_work));
  226. if (net_work == RT_NULL)
  227. {
  228. LOG_W("No memory for network interface device(%s) delay work.", netdev->name);
  229. return -1;
  230. }
  231. rt_delayed_work_init(net_work, check_netdev_internet_up_work, (void *)netdev);
  232. rt_work_submit(&(net_work->work), RT_TICK_PER_SECOND);
  233. return 0;
  234. }
  235. /**
  236. * This function will register TLS protocol to the global TLS protocol.
  237. *
  238. * @param pt TLS protocol object
  239. *
  240. * @return 0: TLS protocol object register success
  241. */
  242. #ifdef SAL_USING_TLS
  243. int sal_proto_tls_register(const struct sal_proto_tls *pt)
  244. {
  245. RT_ASSERT(pt);
  246. proto_tls = (struct sal_proto_tls *) pt;
  247. return 0;
  248. }
  249. #endif
  250. /**
  251. * This function will get sal socket object by sal socket descriptor.
  252. *
  253. * @param socket sal socket index
  254. *
  255. * @return sal socket object of the current sal socket index
  256. */
  257. struct sal_socket *sal_get_socket(int socket)
  258. {
  259. struct sal_socket_table *st = &socket_table;
  260. if (socket < 0 || socket >= (int) st->max_socket)
  261. {
  262. return RT_NULL;
  263. }
  264. socket = socket - SAL_SOCKET_OFFSET;
  265. /* check socket structure valid or not */
  266. RT_ASSERT(st->sockets[socket]->magic == SAL_SOCKET_MAGIC);
  267. return st->sockets[socket];
  268. }
  269. /**
  270. * This function will lock sal socket.
  271. *
  272. * @note please don't invoke it on ISR.
  273. */
  274. static void sal_lock(void)
  275. {
  276. rt_err_t result;
  277. result = rt_mutex_take(&sal_core_lock, RT_WAITING_FOREVER);
  278. if (result != RT_EOK)
  279. {
  280. RT_ASSERT(0);
  281. }
  282. }
  283. /**
  284. * This function will lock sal socket.
  285. *
  286. * @note please don't invoke it on ISR.
  287. */
  288. static void sal_unlock(void)
  289. {
  290. rt_mutex_release(&sal_core_lock);
  291. }
  292. /**
  293. * This function will clean the netdev.
  294. *
  295. * @note please don't invoke it on ISR.
  296. */
  297. int sal_netdev_cleanup(struct netdev *netdev)
  298. {
  299. int idx = 0, find_dev;
  300. do
  301. {
  302. find_dev = 0;
  303. sal_lock();
  304. for (idx = 0; idx < socket_table.max_socket; idx++)
  305. {
  306. if (socket_table.sockets[idx] && socket_table.sockets[idx]->netdev == netdev)
  307. {
  308. find_dev = 1;
  309. break;
  310. }
  311. }
  312. sal_unlock();
  313. if (find_dev)
  314. {
  315. rt_thread_mdelay(100);
  316. }
  317. }
  318. while (find_dev);
  319. return 0;
  320. }
  321. /**
  322. * This function will initialize sal socket object and set socket options
  323. *
  324. * @param family protocol family
  325. * @param type socket type
  326. * @param protocol transfer Protocol
  327. * @param res sal socket object address
  328. *
  329. * @return 0 : socket initialize success
  330. * -1 : input the wrong family
  331. * -2 : input the wrong socket type
  332. * -3 : get network interface failed
  333. */
  334. static int socket_init(int family, int type, int protocol, struct sal_socket **res)
  335. {
  336. struct sal_socket *sock;
  337. struct sal_proto_family *pf;
  338. struct netdev *netdv_def = netdev_default;
  339. struct netdev *netdev = RT_NULL;
  340. rt_bool_t flag = RT_FALSE;
  341. if (family < 0 || family > AF_MAX)
  342. {
  343. return -1;
  344. }
  345. if (type < 0 || type > SOCK_MAX)
  346. {
  347. return -2;
  348. }
  349. sock = *res;
  350. sock->domain = family;
  351. sock->type = type;
  352. sock->protocol = protocol;
  353. if (netdv_def && netdev_is_up(netdv_def))
  354. {
  355. /* check default network interface device protocol family */
  356. pf = (struct sal_proto_family *) netdv_def->sal_user_data;
  357. if (pf != RT_NULL && pf->skt_ops && (pf->family == family || pf->sec_family == family))
  358. {
  359. sock->netdev = netdv_def;
  360. flag = RT_TRUE;
  361. }
  362. }
  363. if (flag == RT_FALSE)
  364. {
  365. /* get network interface device by protocol family */
  366. netdev = netdev_get_by_family(family);
  367. if (netdev == RT_NULL)
  368. {
  369. LOG_E("not find network interface device by protocol family(%d).", family);
  370. return -3;
  371. }
  372. sock->netdev = netdev;
  373. }
  374. return 0;
  375. }
  376. static int socket_alloc(struct sal_socket_table *st, int f_socket)
  377. {
  378. int idx;
  379. /* find an empty socket entry */
  380. for (idx = f_socket; idx < (int) st->max_socket; idx++)
  381. {
  382. if (st->sockets[idx] == RT_NULL)
  383. {
  384. break;
  385. }
  386. }
  387. /* allocate a larger sockte container */
  388. if (idx == (int) st->max_socket && st->max_socket < SAL_SOCKETS_NUM)
  389. {
  390. int cnt, index;
  391. struct sal_socket **sockets;
  392. /* increase the number of socket with 4 step length */
  393. cnt = st->max_socket + SOCKET_TABLE_STEP_LEN;
  394. cnt = cnt > SAL_SOCKETS_NUM ? SAL_SOCKETS_NUM : cnt;
  395. sockets = rt_realloc(st->sockets, cnt * sizeof(struct sal_socket *));
  396. if (sockets == RT_NULL)
  397. goto __result; /* return st->max_socket */
  398. /* clean the new allocated fds */
  399. for (index = st->max_socket; index < cnt; index++)
  400. {
  401. sockets[index] = RT_NULL;
  402. }
  403. st->sockets = sockets;
  404. st->max_socket = cnt;
  405. }
  406. /* allocate 'struct sal_socket' */
  407. if (idx < (int) st->max_socket && st->sockets[idx] == RT_NULL)
  408. {
  409. st->sockets[idx] = rt_calloc(1, sizeof(struct sal_socket));
  410. if (st->sockets[idx] == RT_NULL)
  411. {
  412. idx = st->max_socket;
  413. }
  414. }
  415. __result:
  416. return idx;
  417. }
  418. static void socket_free(struct sal_socket_table *st, int idx)
  419. {
  420. struct sal_socket *sock;
  421. sock = st->sockets[idx];
  422. st->sockets[idx] = RT_NULL;
  423. rt_free(sock);
  424. }
  425. static int socket_new(void)
  426. {
  427. struct sal_socket *sock;
  428. struct sal_socket_table *st = &socket_table;
  429. int idx;
  430. sal_lock();
  431. /* find an empty sal socket entry */
  432. idx = socket_alloc(st, 0);
  433. /* can't find an empty sal socket entry */
  434. if (idx == (int) st->max_socket)
  435. {
  436. idx = -(1 + SAL_SOCKET_OFFSET);
  437. goto __result;
  438. }
  439. sock = st->sockets[idx];
  440. sock->socket = idx + SAL_SOCKET_OFFSET;
  441. sock->magic = SAL_SOCKET_MAGIC;
  442. sock->netdev = RT_NULL;
  443. sock->user_data = RT_NULL;
  444. #ifdef SAL_USING_TLS
  445. sock->user_data_tls = RT_NULL;
  446. #endif
  447. __result:
  448. sal_unlock();
  449. return idx + SAL_SOCKET_OFFSET;
  450. }
  451. static void socket_delete(int socket)
  452. {
  453. struct sal_socket *sock;
  454. struct sal_socket_table *st = &socket_table;
  455. int idx;
  456. idx = socket - SAL_SOCKET_OFFSET;
  457. if (idx < 0 || idx >= (int) st->max_socket)
  458. {
  459. return;
  460. }
  461. sal_lock();
  462. sock = sal_get_socket(socket);
  463. RT_ASSERT(sock != RT_NULL);
  464. sock->magic = 0;
  465. sock->netdev = RT_NULL;
  466. socket_free(st, idx);
  467. sal_unlock();
  468. }
  469. int sal_accept(int socket, struct sockaddr *addr, socklen_t *addrlen)
  470. {
  471. int new_socket;
  472. struct sal_socket *sock;
  473. struct sal_proto_family *pf;
  474. /* get the socket object by socket descriptor */
  475. SAL_SOCKET_OBJ_GET(sock, socket);
  476. /* check the network interface socket operations */
  477. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, accept);
  478. new_socket = pf->skt_ops->accept((int) sock->user_data, addr, addrlen);
  479. if (new_socket != -1)
  480. {
  481. int retval;
  482. int new_sal_socket;
  483. struct sal_socket *new_sock;
  484. /* allocate a new socket structure and registered socket options */
  485. new_sal_socket = socket_new();
  486. new_sock = sal_get_socket(new_sal_socket);
  487. if (new_sock == RT_NULL)
  488. {
  489. pf->skt_ops->closesocket(new_socket);
  490. return -1;
  491. }
  492. retval = socket_init(sock->domain, sock->type, sock->protocol, &new_sock);
  493. if (retval < 0)
  494. {
  495. pf->skt_ops->closesocket(new_socket);
  496. rt_memset(new_sock, 0x00, sizeof(struct sal_socket));
  497. /* socket init failed, delete socket */
  498. socket_delete(new_sal_socket);
  499. LOG_E("New socket registered failed, return error %d.", retval);
  500. return -1;
  501. }
  502. /* socket structure user_data used to store the acquired new socket */
  503. new_sock->user_data = (void *) new_socket;
  504. return new_sal_socket;
  505. }
  506. return -1;
  507. }
  508. static void sal_sockaddr_to_ipaddr(const struct sockaddr *name, ip_addr_t *local_ipaddr)
  509. {
  510. const struct sockaddr_in *svr_addr = (const struct sockaddr_in *) name;
  511. #if NETDEV_IPV4 && NETDEV_IPV6
  512. local_ipaddr->u_addr.ip4.addr = svr_addr->sin_addr.s_addr;
  513. local_ipaddr->type = IPADDR_TYPE_V4;
  514. #elif NETDEV_IPV4
  515. local_ipaddr->addr = svr_addr->sin_addr.s_addr;
  516. #elif NETDEV_IPV6
  517. #error "not only support IPV6"
  518. #endif /* NETDEV_IPV4 && NETDEV_IPV6*/
  519. }
  520. int sal_bind(int socket, const struct sockaddr *name, socklen_t namelen)
  521. {
  522. struct sal_socket *sock;
  523. struct sal_proto_family *pf;
  524. ip_addr_t input_ipaddr;
  525. RT_ASSERT(name);
  526. /* get the socket object by socket descriptor */
  527. SAL_SOCKET_OBJ_GET(sock, socket);
  528. /* bind network interface by ip address */
  529. sal_sockaddr_to_ipaddr(name, &input_ipaddr);
  530. /* check input ipaddr is default netdev ipaddr */
  531. if (!ip_addr_isany_val(input_ipaddr))
  532. {
  533. struct sal_proto_family *input_pf = RT_NULL, *local_pf = RT_NULL;
  534. struct netdev *new_netdev = RT_NULL;
  535. new_netdev = netdev_get_by_ipaddr(&input_ipaddr);
  536. if (new_netdev == RT_NULL)
  537. {
  538. return -1;
  539. }
  540. /* get input and local ip address proto_family */
  541. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, local_pf, bind);
  542. SAL_NETDEV_SOCKETOPS_VALID(new_netdev, input_pf, bind);
  543. /* check the network interface protocol family type */
  544. if (input_pf->family != local_pf->family)
  545. {
  546. int new_socket = -1;
  547. /* protocol family is different, close old socket and create new socket by input ip address */
  548. local_pf->skt_ops->closesocket(socket);
  549. new_socket = input_pf->skt_ops->socket(input_pf->family, sock->type, sock->protocol);
  550. if (new_socket < 0)
  551. {
  552. return -1;
  553. }
  554. sock->netdev = new_netdev;
  555. sock->user_data = (void *) new_socket;
  556. }
  557. }
  558. /* check and get protocol families by the network interface device */
  559. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, bind);
  560. return pf->skt_ops->bind((int) sock->user_data, name, namelen);
  561. }
  562. int sal_shutdown(int socket, int how)
  563. {
  564. struct sal_socket *sock;
  565. struct sal_proto_family *pf;
  566. int error = 0;
  567. /* get the socket object by socket descriptor */
  568. SAL_SOCKET_OBJ_GET(sock, socket);
  569. /* shutdown operation not nead to check network interface status */
  570. /* check the network interface socket opreation */
  571. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, shutdown);
  572. if (pf->skt_ops->shutdown((int) sock->user_data, how) == 0)
  573. {
  574. #ifdef SAL_USING_TLS
  575. if (SAL_SOCKOPS_PROTO_TLS_VALID(sock, closesocket))
  576. {
  577. if (proto_tls->ops->closesocket(sock->user_data_tls) < 0)
  578. {
  579. return -1;
  580. }
  581. }
  582. #endif
  583. error = 0;
  584. }
  585. else
  586. {
  587. error = -1;
  588. }
  589. return error;
  590. }
  591. int sal_getpeername(int socket, struct sockaddr *name, socklen_t *namelen)
  592. {
  593. struct sal_socket *sock;
  594. struct sal_proto_family *pf;
  595. /* get the socket object by socket descriptor */
  596. SAL_SOCKET_OBJ_GET(sock, socket);
  597. /* check the network interface socket opreation */
  598. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, getpeername);
  599. return pf->skt_ops->getpeername((int) sock->user_data, name, namelen);
  600. }
  601. int sal_getsockname(int socket, struct sockaddr *name, socklen_t *namelen)
  602. {
  603. struct sal_socket *sock;
  604. struct sal_proto_family *pf;
  605. /* get socket object by socket descriptor */
  606. SAL_SOCKET_OBJ_GET(sock, socket);
  607. /* check the network interface socket opreation */
  608. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, getsockname);
  609. return pf->skt_ops->getsockname((int) sock->user_data, name, namelen);
  610. }
  611. int sal_getsockopt(int socket, int level, int optname, void *optval, socklen_t *optlen)
  612. {
  613. struct sal_socket *sock;
  614. struct sal_proto_family *pf;
  615. /* get the socket object by socket descriptor */
  616. SAL_SOCKET_OBJ_GET(sock, socket);
  617. /* check the network interface socket opreation */
  618. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, getsockopt);
  619. return pf->skt_ops->getsockopt((int) sock->user_data, level, optname, optval, optlen);
  620. }
  621. int sal_setsockopt(int socket, int level, int optname, const void *optval, socklen_t optlen)
  622. {
  623. struct sal_socket *sock;
  624. struct sal_proto_family *pf;
  625. /* get the socket object by socket descriptor */
  626. SAL_SOCKET_OBJ_GET(sock, socket);
  627. /* check the network interface socket opreation */
  628. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, setsockopt);
  629. #ifdef SAL_USING_TLS
  630. if (level == SOL_TLS)
  631. {
  632. switch (optname)
  633. {
  634. case TLS_CRET_LIST:
  635. SAL_SOCKOPT_PROTO_TLS_EXEC(sock, set_cret_list, optval, optlen);
  636. break;
  637. case TLS_CIPHERSUITE_LIST:
  638. SAL_SOCKOPT_PROTO_TLS_EXEC(sock, set_ciphersurite, optval, optlen);
  639. break;
  640. case TLS_PEER_VERIFY:
  641. SAL_SOCKOPT_PROTO_TLS_EXEC(sock, set_peer_verify, optval, optlen);
  642. break;
  643. case TLS_DTLS_ROLE:
  644. SAL_SOCKOPT_PROTO_TLS_EXEC(sock, set_dtls_role, optval, optlen);
  645. break;
  646. default:
  647. return -1;
  648. }
  649. return 0;
  650. }
  651. else
  652. {
  653. return pf->skt_ops->setsockopt((int) sock->user_data, level, optname, optval, optlen);
  654. }
  655. #else
  656. return pf->skt_ops->setsockopt((int) sock->user_data, level, optname, optval, optlen);
  657. #endif /* SAL_USING_TLS */
  658. }
  659. int sal_connect(int socket, const struct sockaddr *name, socklen_t namelen)
  660. {
  661. struct sal_socket *sock;
  662. struct sal_proto_family *pf;
  663. int ret;
  664. /* get the socket object by socket descriptor */
  665. SAL_SOCKET_OBJ_GET(sock, socket);
  666. /* check the network interface is up status */
  667. SAL_NETDEV_IS_UP(sock->netdev);
  668. /* check the network interface socket opreation */
  669. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, connect);
  670. ret = pf->skt_ops->connect((int) sock->user_data, name, namelen);
  671. #ifdef SAL_USING_TLS
  672. if (ret >= 0 && SAL_SOCKOPS_PROTO_TLS_VALID(sock, connect))
  673. {
  674. if (proto_tls->ops->connect(sock->user_data_tls) < 0)
  675. {
  676. return -1;
  677. }
  678. return ret;
  679. }
  680. #endif
  681. return ret;
  682. }
  683. int sal_listen(int socket, int backlog)
  684. {
  685. struct sal_socket *sock;
  686. struct sal_proto_family *pf;
  687. /* get the socket object by socket descriptor */
  688. SAL_SOCKET_OBJ_GET(sock, socket);
  689. /* check the network interface socket opreation */
  690. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, listen);
  691. return pf->skt_ops->listen((int) sock->user_data, backlog);
  692. }
  693. int sal_recvfrom(int socket, void *mem, size_t len, int flags,
  694. struct sockaddr *from, socklen_t *fromlen)
  695. {
  696. struct sal_socket *sock;
  697. struct sal_proto_family *pf;
  698. /* get the socket object by socket descriptor */
  699. SAL_SOCKET_OBJ_GET(sock, socket);
  700. /* check the network interface is up status */
  701. SAL_NETDEV_IS_UP(sock->netdev);
  702. /* check the network interface socket opreation */
  703. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, recvfrom);
  704. #ifdef SAL_USING_TLS
  705. if (SAL_SOCKOPS_PROTO_TLS_VALID(sock, recv))
  706. {
  707. int ret;
  708. if ((ret = proto_tls->ops->recv(sock->user_data_tls, mem, len)) < 0)
  709. {
  710. return -1;
  711. }
  712. return ret;
  713. }
  714. else
  715. {
  716. return pf->skt_ops->recvfrom((int) sock->user_data, mem, len, flags, from, fromlen);
  717. }
  718. #else
  719. return pf->skt_ops->recvfrom((int) sock->user_data, mem, len, flags, from, fromlen);
  720. #endif
  721. }
  722. int sal_sendto(int socket, const void *dataptr, size_t size, int flags,
  723. const struct sockaddr *to, socklen_t tolen)
  724. {
  725. struct sal_socket *sock;
  726. struct sal_proto_family *pf;
  727. /* get the socket object by socket descriptor */
  728. SAL_SOCKET_OBJ_GET(sock, socket);
  729. /* check the network interface is up status */
  730. SAL_NETDEV_IS_UP(sock->netdev);
  731. /* check the network interface socket opreation */
  732. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, sendto);
  733. #ifdef SAL_USING_TLS
  734. if (SAL_SOCKOPS_PROTO_TLS_VALID(sock, send))
  735. {
  736. int ret;
  737. if ((ret = proto_tls->ops->send(sock->user_data_tls, dataptr, size)) < 0)
  738. {
  739. return -1;
  740. }
  741. return ret;
  742. }
  743. else
  744. {
  745. return pf->skt_ops->sendto((int) sock->user_data, dataptr, size, flags, to, tolen);
  746. }
  747. #else
  748. return pf->skt_ops->sendto((int) sock->user_data, dataptr, size, flags, to, tolen);
  749. #endif
  750. }
  751. int sal_socket(int domain, int type, int protocol)
  752. {
  753. int retval;
  754. int socket, proto_socket;
  755. struct sal_socket *sock;
  756. struct sal_proto_family *pf;
  757. /* allocate a new socket and registered socket options */
  758. socket = socket_new();
  759. if (socket < 0)
  760. {
  761. return -1;
  762. }
  763. /* get sal socket object by socket descriptor */
  764. sock = sal_get_socket(socket);
  765. if (sock == RT_NULL)
  766. {
  767. return -1;
  768. }
  769. /* Initialize sal socket object */
  770. retval = socket_init(domain, type, protocol, &sock);
  771. if (retval < 0)
  772. {
  773. LOG_E("SAL socket protocol family input failed, return error %d.", retval);
  774. socket_delete(socket);
  775. return -1;
  776. }
  777. /* valid the network interface socket opreation */
  778. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, socket);
  779. proto_socket = pf->skt_ops->socket(domain, type, protocol);
  780. if (proto_socket >= 0)
  781. {
  782. #ifdef SAL_USING_TLS
  783. if (SAL_SOCKOPS_PROTO_TLS_VALID(sock, socket))
  784. {
  785. sock->user_data_tls = proto_tls->ops->socket(socket);
  786. if (sock->user_data_tls == RT_NULL)
  787. {
  788. socket_delete(socket);
  789. return -1;
  790. }
  791. }
  792. #endif
  793. sock->user_data = (void *) proto_socket;
  794. return sock->socket;
  795. }
  796. return -1;
  797. }
  798. int sal_closesocket(int socket)
  799. {
  800. struct sal_socket *sock;
  801. struct sal_proto_family *pf;
  802. int error = 0;
  803. /* get the socket object by socket descriptor */
  804. SAL_SOCKET_OBJ_GET(sock, socket);
  805. /* clsoesocket operation not nead to vaild network interface status */
  806. /* valid the network interface socket opreation */
  807. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, socket);
  808. if (pf->skt_ops->closesocket((int) sock->user_data) == 0)
  809. {
  810. #ifdef SAL_USING_TLS
  811. if (SAL_SOCKOPS_PROTO_TLS_VALID(sock, closesocket))
  812. {
  813. if (proto_tls->ops->closesocket(sock->user_data_tls) < 0)
  814. {
  815. return -1;
  816. }
  817. }
  818. #endif
  819. error = 0;
  820. }
  821. else
  822. {
  823. error = -1;
  824. }
  825. /* delete socket */
  826. socket_delete(socket);
  827. return error;
  828. }
  829. int sal_ioctlsocket(int socket, long cmd, void *arg)
  830. {
  831. struct sal_socket *sock;
  832. struct sal_proto_family *pf;
  833. /* get the socket object by socket descriptor */
  834. SAL_SOCKET_OBJ_GET(sock, socket);
  835. /* check the network interface socket opreation */
  836. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, ioctlsocket);
  837. return pf->skt_ops->ioctlsocket((int) sock->user_data, cmd, arg);
  838. }
  839. #ifdef SAL_USING_POSIX
  840. int sal_poll(struct dfs_fd *file, struct rt_pollreq *req)
  841. {
  842. struct sal_socket *sock;
  843. struct sal_proto_family *pf;
  844. int socket = (int) file->data;
  845. /* get the socket object by socket descriptor */
  846. SAL_SOCKET_OBJ_GET(sock, socket);
  847. /* check the network interface is up status */
  848. SAL_NETDEV_IS_UP(sock->netdev);
  849. /* check the network interface socket opreation */
  850. SAL_NETDEV_SOCKETOPS_VALID(sock->netdev, pf, poll);
  851. return pf->skt_ops->poll(file, req);
  852. }
  853. #endif
  854. struct hostent *sal_gethostbyname(const char *name)
  855. {
  856. struct netdev *netdev = netdev_default;
  857. struct sal_proto_family *pf;
  858. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, gethostbyname))
  859. {
  860. return pf->netdb_ops->gethostbyname(name);
  861. }
  862. else
  863. {
  864. /* get the first network interface device with up status */
  865. netdev = netdev_get_first_by_flags(NETDEV_FLAG_UP);
  866. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, gethostbyname))
  867. {
  868. return pf->netdb_ops->gethostbyname(name);
  869. }
  870. }
  871. return RT_NULL;
  872. }
  873. int sal_gethostbyname_r(const char *name, struct hostent *ret, char *buf,
  874. size_t buflen, struct hostent **result, int *h_errnop)
  875. {
  876. struct netdev *netdev = netdev_default;
  877. struct sal_proto_family *pf;
  878. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, gethostbyname_r))
  879. {
  880. return pf->netdb_ops->gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
  881. }
  882. else
  883. {
  884. /* get the first network interface device with up status */
  885. netdev = netdev_get_first_by_flags(NETDEV_FLAG_UP);
  886. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, gethostbyname_r))
  887. {
  888. return pf->netdb_ops->gethostbyname_r(name, ret, buf, buflen, result, h_errnop);
  889. }
  890. }
  891. return -1;
  892. }
  893. int sal_getaddrinfo(const char *nodename,
  894. const char *servname,
  895. const struct addrinfo *hints,
  896. struct addrinfo **res)
  897. {
  898. struct netdev *netdev = netdev_default;
  899. struct sal_proto_family *pf;
  900. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, getaddrinfo))
  901. {
  902. return pf->netdb_ops->getaddrinfo(nodename, servname, hints, res);
  903. }
  904. else
  905. {
  906. /* get the first network interface device with up status */
  907. netdev = netdev_get_first_by_flags(NETDEV_FLAG_UP);
  908. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, getaddrinfo))
  909. {
  910. return pf->netdb_ops->getaddrinfo(nodename, servname, hints, res);
  911. }
  912. }
  913. return -1;
  914. }
  915. void sal_freeaddrinfo(struct addrinfo *ai)
  916. {
  917. struct netdev *netdev = netdev_default;
  918. struct sal_proto_family *pf;
  919. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, freeaddrinfo))
  920. {
  921. pf->netdb_ops->freeaddrinfo(ai);
  922. }
  923. else
  924. {
  925. /* get the first network interface device with up status */
  926. netdev = netdev_get_first_by_flags(NETDEV_FLAG_UP);
  927. if (SAL_NETDEV_NETDBOPS_VALID(netdev, pf, freeaddrinfo))
  928. {
  929. pf->netdb_ops->freeaddrinfo(ai);
  930. }
  931. }
  932. }