PageRenderTime 57ms CodeModel.GetById 24ms RepoModel.GetById 1ms app.codeStats 0ms

/peek-build/m23/g23m-fad/tcpip/socket_api.c

https://bitbucket.org/C0deMaver1ck/peeklinux
C | 1658 lines | 1121 code | 325 blank | 212 comment | 114 complexity | 283744c86590d751da6a488c017d5ce1 MD5 | raw file
Possible License(s): GPL-2.0, LGPL-2.1, LGPL-2.0

Large files files are truncated, but you can click here to view the full file

  1. /*
  2. +------------------------------------------------------------------------------
  3. | File: socket.c
  4. +------------------------------------------------------------------------------
  5. | Copyright 2002 Texas Instruments Berlin, AG
  6. | All rights reserved.
  7. |
  8. | This file is confidential and a trade secret of Texas
  9. | Instruments Berlin, AG
  10. | The receipt of or possession of this file does not convey
  11. | any rights to reproduce or disclose its contents or to
  12. | manufacture, use, or sell anything it may describe, in
  13. | whole, or in part, without the specific written consent of
  14. | Texas Instruments Berlin, AG.
  15. +-----------------------------------------------------------------------------
  16. | Purpose : This file implements the socket API functionality.
  17. | For a description of this file read g23m\condat\doc\8462_601.doc
  18. +-----------------------------------------------------------------------------
  19. */
  20. #ifndef SAP_DCM
  21. #define SAP_DCM
  22. #endif /* !SAP_DCM */
  23. #define ENTITY_TCPIP
  24. #include <string.h>
  25. #include <stdio.h>
  26. #include <stdlib.h>
  27. #include "socket_api.h"
  28. #include "custom.h"
  29. #include "pei.h"
  30. #include "socket_int.h"
  31. #include "dcm.h"
  32. #include "aci_all.h"
  33. LOCAL const int UNUSED = 0;
  34. /* this function maps the DCM result codes to the Socket-API result codes */
  35. LOCAL T_SOCK_RESULT map_dcm_result_code(S32 result)
  36. {
  37. switch(result)
  38. {
  39. case DCM_OK: return SOCK_RESULT_OK;
  40. case DCM_NOT_READY: return SOCK_RESULT_NOT_READY;
  41. case DCM_ALREADY_ACTIVATED: return SOCK_RESULT_BEARER_ACTIVE;
  42. case DCM_UNKNOWN_EVENT: return SOCK_RESULT_INTERNAL_ERROR;
  43. case DCM_INVALID_PARAMETER: return SOCK_RESULT_INVALID_PARAMETER;
  44. case DCM_BUSY: return SOCK_RESULT_IN_PROGRESS;
  45. case DCM_PS_CONN_BROKEN: return SOCK_RESULT_NETWORK_LOST;
  46. case DCM_NO_NETWORK: return SOCK_RESULT_BEARER_NOT_READY;
  47. default: return SOCK_RESULT_INTERNAL_ERROR;
  48. }
  49. }
  50. /*******************************************************************************
  51. ** Function : FindSocketData
  52. ** Parameter : T_SOCK_API_INSTANCE_DATA*
  53. ** T_SOCK_SOCKET
  54. ** Description : The function returns a pointer to the data structure of a socket.
  55. ** If the socket does not exist or api_data is NULL,
  56. ** then it returns NULL.
  57. *******************************************************************************/
  58. LOCAL T_SOCK_SOCKET_DATA* FindSocketData(T_SOCK_API_INSTANCE_DATA* api_data,
  59. T_SOCK_SOCKET tcpip_socket)
  60. {
  61. T_SOCK_SOCKET_DATA* socket_data;
  62. TRACE_FUNCTION("FindSocketData()");
  63. /* must be checked whether api_data is NULL or not.*/
  64. if(api_data != NULL)
  65. socket_data = api_data->socket_data;
  66. else
  67. {
  68. TRACE_ERROR("FindSocketData: api_data = NULL!");
  69. return NULL;
  70. }
  71. TRACE_EVENT_P2("FindSocketData() cached: %08X, search: %08X", socket_data, tcpip_socket);
  72. while((socket_data != NULL) && (tcpip_socket != socket_data->tcpip_socket))
  73. {
  74. socket_data = socket_data->next_socket_data;
  75. TRACE_EVENT_P2("FindSocketData() next: %08X, search: %08X", socket_data, tcpip_socket);
  76. }
  77. TRACE_EVENT_P2("FindSocketData: tcpip_data=%x, ret=%x",tcpip_socket,socket_data );
  78. return socket_data;
  79. } /* FindSocketData */
  80. /*******************************************************************************
  81. ** Function : ReleaseSocketData
  82. ** Parameter : T_SOCK_API_INSTANCE_DATA*
  83. ** T_SOCK_SOCKET_DATA*
  84. ** Description : The function releases the specified socket data.
  85. *******************************************************************************/
  86. static void ReleaseSocketData(T_SOCK_API_INSTANCE_DATA* api_data,
  87. T_SOCK_SOCKET_DATA* socket_data)
  88. {
  89. T_SOCK_SOCKET_DATA* temp_socket_data;
  90. TRACE_FUNCTION("ReleaseSocketData()");
  91. /* take socket data from linked list */
  92. if(api_data->socket_data == socket_data)
  93. {
  94. api_data->socket_data = socket_data->next_socket_data;
  95. }
  96. else
  97. {
  98. temp_socket_data = api_data->socket_data;
  99. while(temp_socket_data->next_socket_data != socket_data)
  100. {
  101. temp_socket_data = temp_socket_data->next_socket_data;
  102. }
  103. temp_socket_data->next_socket_data = socket_data->next_socket_data;
  104. }
  105. /* release socket data */
  106. MFREE(socket_data);
  107. } /* ReleaseSocketData */
  108. /******************************************************************************/
  109. BOOL sock_api_initialize(T_SOCK_API_INSTANCE *api_instance,
  110. T_HANDLE app_handle,
  111. char* app_name)
  112. {
  113. T_SOCK_API_INSTANCE_DATA* api_data_p;
  114. T_HANDLE hCommAPP;
  115. T_HANDLE hCommTCPIP;
  116. T_HANDLE hCommDCM;
  117. TRACE_FUNCTION("[Socket API] sock_api_initialize()");
  118. /* open communication handles */
  119. if((hCommTCPIP = vsi_c_open (app_handle, TCPIP_NAME)) < VSI_OK)
  120. {
  121. TRACE_ERROR( "sock_api_initialize: vsi_c_open(TCP) failed");
  122. return FALSE;
  123. }
  124. if((hCommAPP = vsi_c_open (app_handle, app_name)) < VSI_OK)
  125. {
  126. TRACE_ERROR( "sock_api_initialize: vsi_c_open(APP) failed");
  127. return FALSE;
  128. }
  129. if((hCommDCM = vsi_c_open (app_handle, DCM_NAME)) < VSI_OK)
  130. {
  131. TRACE_ERROR( "sock_api_initialize: vsi_c_open(DCM) failed");
  132. return FALSE;
  133. }
  134. /* initialization successful */
  135. /* allocate API Data structure */
  136. MALLOC(api_data_p, sizeof(T_SOCK_API_INSTANCE_DATA));
  137. /*initialize API Data */
  138. api_data_p->app_handle = app_handle;
  139. api_data_p->hCommAPP = hCommAPP;
  140. api_data_p->hCommTCPIP = hCommTCPIP;
  141. api_data_p->hCommDCM = hCommDCM;
  142. api_data_p->socket_data = NULL;
  143. /* derefernce 'api_instance' and save address of 'api_data' */
  144. *api_instance = (T_SOCK_API_INSTANCE)api_data_p;
  145. return TRUE;
  146. } /* sock_api_initialize */
  147. /******************************************************************************/
  148. void sock_api_deinitialize(T_SOCK_API_INSTANCE api_instance)
  149. {
  150. T_SOCK_API_INSTANCE_DATA* api_data_p;
  151. T_SOCK_SOCKET_DATA* socket_data1;
  152. T_SOCK_SOCKET_DATA* socket_data2;
  153. TRACE_FUNCTION("[Socket API] sock_api_deinitialize()");
  154. /* get the address of 'api_data' */
  155. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  156. /*close communication channels */
  157. vsi_c_close (api_data_p->app_handle, api_data_p->hCommAPP);
  158. vsi_c_close (api_data_p->app_handle, api_data_p->hCommTCPIP);
  159. vsi_c_close (api_data_p->app_handle, api_data_p->hCommDCM);
  160. /* release all socket data */
  161. socket_data1 = api_data_p->socket_data;
  162. while(socket_data1 != NULL)
  163. {
  164. socket_data2 = socket_data1;
  165. socket_data1 = socket_data1->next_socket_data;
  166. MFREE(socket_data2);
  167. }
  168. /* release API data */
  169. MFREE(api_data_p);
  170. }
  171. /******************************************************************************/
  172. T_SOCK_RESULT sock_open_bearer(T_SOCK_API_INSTANCE api_instance,
  173. T_SOCK_BEARER_TYPE bearer_select,
  174. int profile_number,
  175. T_SOCK_BEARER_INFO *params,
  176. T_SOCK_CALLBACK sock_cb,
  177. void *context)
  178. {
  179. T_SOCK_API_INSTANCE_DATA* api_data_p;
  180. TRACE_FUNCTION("[Socket API] sock_open_bearer()");
  181. if(sock_cb EQ NULL)
  182. return SOCK_RESULT_INVALID_PARAMETER;
  183. /* set API data pointer */
  184. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  185. api_data_p->context = context;
  186. api_data_p->callback = sock_cb;
  187. /* send primitive to DCM */
  188. {
  189. PALLOC(dcm_open_conn_req, DCM_OPEN_CONN_REQ);
  190. dcm_open_conn_req->api_instance = api_instance;
  191. dcm_open_conn_req->bearer_select = bearer_select;
  192. dcm_open_conn_req->profile_number = profile_number;
  193. dcm_open_conn_req->dcm_info_conn.bearer_handle = UNUSED;
  194. dcm_open_conn_req->dcm_info_conn.app_handle = params->app_handle;
  195. dcm_open_conn_req->dcm_info_conn.bearer_type = params->bearer_type;
  196. dcm_open_conn_req->dcm_info_conn.apn_valid = params->apn_valid;
  197. memcpy(dcm_open_conn_req->dcm_info_conn.apn, params->apn, SOCK_MAX_APN_LEN+1);
  198. dcm_open_conn_req->dcm_info_conn.phone_number_valid = params->phone_nr_valid;
  199. memcpy(dcm_open_conn_req->dcm_info_conn.phone_number, params->phone_nr,
  200. SOCK_MAX_PHONENUM_LEN+1);
  201. dcm_open_conn_req->dcm_info_conn.user_id_valid = params->user_id_valid;
  202. memcpy(dcm_open_conn_req->dcm_info_conn.user_id, params->user_id,
  203. SOCK_MAX_USERID_LEN+1);
  204. dcm_open_conn_req->dcm_info_conn.password_valid = params->password_valid;
  205. memcpy(dcm_open_conn_req->dcm_info_conn.password, params->password,
  206. SOCK_MAX_PASSWORD_LEN+1);
  207. dcm_open_conn_req->dcm_info_conn.cid = params->cid;
  208. dcm_open_conn_req->dcm_info_conn.ip_address = params->ip_address;
  209. dcm_open_conn_req->dcm_info_conn.dns1 = params->dns1;
  210. dcm_open_conn_req->dcm_info_conn.dns2 = params->dns2;
  211. dcm_open_conn_req->dcm_info_conn.gateway = params->gateway;
  212. dcm_open_conn_req->dcm_info_conn.auth_type = params->authtype;
  213. dcm_open_conn_req->dcm_info_conn.data_compr = params->data_compr;
  214. dcm_open_conn_req->dcm_info_conn.header_compr = params->header_comp;
  215. dcm_open_conn_req->dcm_info_conn.precedence = params->precedence;
  216. dcm_open_conn_req->dcm_info_conn.delay = params->precedence;
  217. dcm_open_conn_req->dcm_info_conn.reliability = params->reliability;
  218. dcm_open_conn_req->dcm_info_conn.peak_throughput = params->peak_throughput;
  219. dcm_open_conn_req->dcm_info_conn.mean_throughput = params->mean_througput;
  220. dcm_open_conn_req->dcm_info_conn.shareable = params->shareable;
  221. PSEND(api_data_p->hCommDCM, dcm_open_conn_req);
  222. }
  223. return SOCK_RESULT_OK;
  224. }
  225. /******************************************************************************/
  226. LOCAL void sock_open_bearer_cnf(T_DCM_OPEN_CONN_CNF *dcm_open_conn_cnf,
  227. T_SOCK_API_INSTANCE api_instance)
  228. {
  229. T_SOCK_OPEN_BEARER_CNF sock_open_bearer_cnf;
  230. T_SOCK_API_INSTANCE_DATA *api_data_p;
  231. TRACE_FUNCTION("[Socket API] sock_open_bearer_cnf()");
  232. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  233. /* fill signal struct */
  234. sock_open_bearer_cnf.result = map_dcm_result_code(dcm_open_conn_cnf->result);
  235. sock_open_bearer_cnf.socket = UNUSED;
  236. sock_open_bearer_cnf.event_type = SOCK_OPEN_BEARER_CNF;
  237. sock_open_bearer_cnf.bearer_handle = dcm_open_conn_cnf->bearer_handle;
  238. /* release primitive */
  239. PFREE(dcm_open_conn_cnf);
  240. api_data_p->callback((T_SOCK_EVENTSTRUCT *)&sock_open_bearer_cnf,
  241. api_data_p->context);
  242. }
  243. /******************************************************************************/
  244. T_SOCK_RESULT sock_close_bearer(T_SOCK_API_INSTANCE api_instance,
  245. T_SOCK_BEARER_HANDLE bearer_handle,
  246. T_SOCK_CALLBACK sock_cb,
  247. void *context)
  248. {
  249. T_SOCK_API_INSTANCE_DATA* api_data_p;
  250. TRACE_FUNCTION("[Socket API] sock_close_bearer()");
  251. if(sock_cb EQ NULL) {
  252. return SOCK_RESULT_INVALID_PARAMETER;
  253. }
  254. /* set API data pointer */
  255. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  256. api_data_p->callback = sock_cb;
  257. api_data_p->context = context;
  258. /* send primitive to DCM */
  259. {
  260. PALLOC(dcm_close_conn_req, DCM_CLOSE_CONN_REQ);
  261. dcm_close_conn_req->api_instance = api_instance;
  262. dcm_close_conn_req->bearer_handle = bearer_handle;
  263. PSEND(api_data_p->hCommDCM, dcm_close_conn_req);
  264. }
  265. return SOCK_RESULT_OK;
  266. }
  267. /******************************************************************************/
  268. LOCAL void sock_close_bearer_cnf(T_DCM_CLOSE_CONN_CNF *dcm_close_conn_cnf,
  269. T_SOCK_API_INSTANCE api_instance)
  270. {
  271. T_SOCK_CLOSE_BEARER_CNF sock_close_bearer_cnf;
  272. T_SOCK_API_INSTANCE_DATA *api_data_p;
  273. TRACE_FUNCTION("[Socket API] dcm_close_conn_cnf()");
  274. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  275. sock_close_bearer_cnf.result = map_dcm_result_code(dcm_close_conn_cnf->result);
  276. sock_close_bearer_cnf.socket = UNUSED;
  277. sock_close_bearer_cnf.event_type = SOCK_CLOSE_BEARER_CNF;
  278. /* release primitive */
  279. PFREE(dcm_close_conn_cnf);
  280. /* call callback function */
  281. api_data_p->callback((T_SOCK_EVENTSTRUCT *)&sock_close_bearer_cnf,
  282. api_data_p->context);
  283. }
  284. /******************************************************************************/
  285. T_SOCK_RESULT sock_bearer_info(T_SOCK_API_INSTANCE api_instance,
  286. T_SOCK_BEARER_HANDLE bearer_handle,
  287. T_SOCK_CALLBACK sock_cb,
  288. void *context)
  289. {
  290. T_SOCK_API_INSTANCE_DATA* api_data_p;
  291. TRACE_FUNCTION("[Socket API] sock_bearer_info()");
  292. if(sock_cb EQ NULL)
  293. return SOCK_RESULT_INVALID_PARAMETER;
  294. /* set API data pointer */
  295. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  296. api_data_p->callback = sock_cb;
  297. api_data_p->context = context;
  298. /* send primitive to DCM */
  299. {
  300. PALLOC(dcm_get_current_conn_req, DCM_GET_CURRENT_CONN_REQ);
  301. dcm_get_current_conn_req->api_instance = api_instance;
  302. dcm_get_current_conn_req->bearer_handle = bearer_handle;
  303. PSEND(api_data_p->hCommDCM, dcm_get_current_conn_req);
  304. }
  305. return SOCK_RESULT_OK;
  306. }
  307. /******************************************************************************/
  308. LOCAL void sock_bearer_info_cnf(T_DCM_GET_CURRENT_CONN_CNF *current_conn_cnf,
  309. T_SOCK_API_INSTANCE api_instance)
  310. {
  311. T_SOCK_BEARER_INFO_CNF bearer_info;
  312. T_SOCK_API_INSTANCE_DATA *api_data_p;
  313. TRACE_FUNCTION("[Socket API] sock_bearer_info_cnf()");
  314. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  315. bearer_info.result = map_dcm_result_code(current_conn_cnf->result);
  316. bearer_info.socket = UNUSED;
  317. bearer_info.event_type = SOCK_BEARER_INFO_CNF;
  318. bearer_info.bearer_params.bearer_handle = current_conn_cnf->dcm_info_conn.bearer_handle;
  319. bearer_info.bearer_params.app_handle = current_conn_cnf->dcm_info_conn.app_handle;
  320. bearer_info.bearer_params.bearer_type =(T_SOCK_BEARER_TYPE)current_conn_cnf->dcm_info_conn.bearer_type;
  321. bearer_info.bearer_params.apn_valid = current_conn_cnf->dcm_info_conn.apn_valid;
  322. memcpy(bearer_info.bearer_params.apn,
  323. current_conn_cnf->dcm_info_conn.apn, SOCK_MAX_APN_LEN);
  324. bearer_info.bearer_params.phone_nr_valid = current_conn_cnf->dcm_info_conn.phone_number_valid;
  325. memcpy(bearer_info.bearer_params.phone_nr,current_conn_cnf->dcm_info_conn.phone_number,
  326. SOCK_MAX_PHONENUM_LEN);
  327. bearer_info.bearer_params.user_id_valid = current_conn_cnf->dcm_info_conn.user_id_valid;
  328. memcpy(bearer_info.bearer_params.user_id, current_conn_cnf->dcm_info_conn.user_id,
  329. SOCK_MAX_USERID_LEN);
  330. bearer_info.bearer_params.password_valid = current_conn_cnf->dcm_info_conn.password_valid;
  331. memcpy(bearer_info.bearer_params.password, current_conn_cnf->dcm_info_conn.password,
  332. SOCK_MAX_PASSWORD_LEN);
  333. bearer_info.bearer_params.cid = current_conn_cnf->dcm_info_conn.cid;
  334. bearer_info.bearer_params.ip_address = current_conn_cnf->dcm_info_conn.ip_address;
  335. bearer_info.bearer_params.dns1 = current_conn_cnf->dcm_info_conn.dns1;
  336. bearer_info.bearer_params.dns2 = current_conn_cnf->dcm_info_conn.dns2;
  337. bearer_info.bearer_params.gateway = current_conn_cnf->dcm_info_conn.gateway;
  338. bearer_info.bearer_params.authtype = (T_SOCK_AUTHTYPE)current_conn_cnf->dcm_info_conn.auth_type;
  339. bearer_info.bearer_params.data_compr = current_conn_cnf->dcm_info_conn.data_compr;
  340. bearer_info.bearer_params.header_comp = current_conn_cnf->dcm_info_conn.header_compr;
  341. bearer_info.bearer_params.precedence = current_conn_cnf->dcm_info_conn.precedence;
  342. bearer_info.bearer_params.delay = current_conn_cnf->dcm_info_conn.delay;
  343. bearer_info.bearer_params.reliability = current_conn_cnf->dcm_info_conn.reliability;
  344. bearer_info.bearer_params.peak_throughput = current_conn_cnf->dcm_info_conn.peak_throughput;
  345. bearer_info.bearer_params.mean_througput = current_conn_cnf->dcm_info_conn.mean_throughput;
  346. bearer_info.bearer_params.shareable = current_conn_cnf->dcm_info_conn.shareable;
  347. /* release primitive */
  348. PFREE(current_conn_cnf);
  349. /* call callback function */
  350. api_data_p->callback((T_SOCK_EVENTSTRUCT *)&bearer_info, api_data_p->context);
  351. }
  352. /******************************************************************************/
  353. LOCAL void sock_dcm_error_ind(T_DCM_ERROR_IND *dcm_error_ind,
  354. T_SOCK_API_INSTANCE api_instance)
  355. {
  356. T_SOCK_BAERER_CLOSED_IND sock_bearer_closed_ind;
  357. T_SOCK_API_INSTANCE_DATA *api_data_p;
  358. TRACE_FUNCTION("[Socket API] sock_dcm_error_ind()");
  359. api_data_p = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  360. sock_bearer_closed_ind.event_type = SOCK_BAERER_CLOSED_IND;
  361. sock_bearer_closed_ind.result = map_dcm_result_code(dcm_error_ind->result);
  362. sock_bearer_closed_ind.socket = UNUSED;
  363. sock_bearer_closed_ind.dcm_error = dcm_error_ind->dcm_err;
  364. PFREE(dcm_error_ind);
  365. if(api_data_p->callback NEQ NULL)
  366. {
  367. api_data_p->callback((T_SOCK_EVENTSTRUCT *)&sock_bearer_closed_ind,
  368. api_data_p->context);
  369. }
  370. }
  371. /* ******************* Socket related functions ***************************** */
  372. /******************************************************************************/
  373. T_SOCK_RESULT sock_create(T_SOCK_API_INSTANCE api_instance,
  374. T_SOCK_IPPROTO ipproto,
  375. T_SOCK_CALLBACK callback,
  376. void* context)
  377. {
  378. T_SOCK_API_INSTANCE_DATA* api_data;
  379. T_SOCK_SOCKET_DATA* socket_data;
  380. TRACE_FUNCTION("[Socket API] sock_create()");
  381. TRACE_EVENT_P1("IP-Protocol=%d",(U32)ipproto);
  382. /* set api_data */
  383. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  384. if(callback EQ NULL)
  385. return SOCK_RESULT_INVALID_PARAMETER;
  386. /* check for correct data */
  387. if((ipproto != SOCK_IPPROTO_UDP) && (ipproto != SOCK_IPPROTO_TCP))
  388. {
  389. TRACE_ERROR("[Socket API] Error: Invalid IP-Protocol");
  390. return SOCK_RESULT_INVALID_PARAMETER;
  391. }
  392. if( api_data == NULL )
  393. {
  394. TRACE_ERROR("[Socket API] Error: api_instance == NULL!");
  395. return SOCK_RESULT_INVALID_PARAMETER;
  396. }
  397. /* allocate socket data */
  398. MALLOC(socket_data, sizeof(T_SOCK_SOCKET_DATA));
  399. /* put socket data in linked list */
  400. socket_data->next_socket_data = api_data->socket_data;
  401. api_data->socket_data = socket_data;
  402. /* initialize socket data */
  403. socket_data->api_data = api_data;
  404. socket_data->tcpip_socket = 0;
  405. socket_data->callback = callback;
  406. socket_data->context = context;
  407. socket_data->rx_flow_control = SOCK_FLOW_XON;
  408. socket_data->tx_flow_control = SOCK_FLOW_XON;
  409. socket_data->rx_window = 1;
  410. socket_data->tx_window = 1;
  411. /* send primitive to TCPIP */
  412. {
  413. PALLOC(tcpip_create_req_prim, TCPIP_CREATE_REQ);
  414. tcpip_create_req_prim->app_handle = api_data->hCommAPP;
  415. tcpip_create_req_prim->ipproto = ipproto;
  416. tcpip_create_req_prim->request_id = (T_SOCK_SOCKET)socket_data;
  417. PSEND(api_data->hCommTCPIP, tcpip_create_req_prim);
  418. }
  419. return SOCK_RESULT_OK;
  420. }/* sock_create */
  421. /*****************************************************************************************
  422. ** Function : sock_create_cnf
  423. ** Parameter : T_TCPIP_CREATE_CNF *
  424. ** T_SOCK_API_INSTANCE ' this value will be ignored in this function
  425. ** because you can find socket_data only using request_id
  426. *****************************************************************************************/
  427. LOCAL void sock_create_cnf(T_TCPIP_CREATE_CNF *tcpip_create_cnf,
  428. T_SOCK_API_INSTANCE api_instance)
  429. {
  430. T_SOCK_SOCKET_DATA* socket_data;
  431. T_SOCK_CREATE_CNF sock_create_cnf;
  432. TRACE_FUNCTION("[Socket API] sock_create_cnf()");
  433. /* set socket data */
  434. socket_data = (T_SOCK_SOCKET_DATA*)tcpip_create_cnf->request_id;
  435. /* set received values */
  436. socket_data->tcpip_socket = tcpip_create_cnf->socket;
  437. /* fill confirm struct */
  438. sock_create_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_create_cnf->event_type;
  439. sock_create_cnf.result = (T_SOCK_RESULT)tcpip_create_cnf->result;
  440. sock_create_cnf.socket = (T_SOCK_SOCKET)socket_data;
  441. socket_data->callback((T_SOCK_EVENTSTRUCT *)&sock_create_cnf, socket_data->context);
  442. /* release socket data if context creation was not successful */
  443. if(tcpip_create_cnf->result != TCPIP_RESULT_OK)
  444. {
  445. TRACE_ERROR("[Socket API] Error: sock_create() failed");
  446. ReleaseSocketData(socket_data->api_data, socket_data);
  447. }
  448. PFREE(tcpip_create_cnf);
  449. }/* sock_create_cnf */
  450. /******************************************************************************/
  451. T_SOCK_RESULT sock_close(T_SOCK_SOCKET socket)
  452. {
  453. T_SOCK_API_INSTANCE_DATA* api_data;
  454. T_SOCK_SOCKET_DATA* sock_data;
  455. TRACE_FUNCTION("[Socket API] sock_close()");
  456. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  457. if(sock_data == NULL)
  458. {
  459. return SOCK_RESULT_INVALID_PARAMETER;
  460. }
  461. api_data = sock_data->api_data;
  462. /* send primitive to TCPIP */
  463. {
  464. PALLOC(tcpip_close_req_prim, TCPIP_CLOSE_REQ);
  465. tcpip_close_req_prim->app_handle = api_data->hCommAPP;
  466. tcpip_close_req_prim->socket = sock_data->tcpip_socket;
  467. PSEND(api_data->hCommTCPIP, tcpip_close_req_prim);
  468. }
  469. return SOCK_RESULT_OK;
  470. }/* sock_close */
  471. /*******************************************************************************
  472. ** Function : sock_close_cnf
  473. ** Parameter : T_SOCK_CLOSE_CNF *
  474. *******************************************************************************/
  475. LOCAL void sock_close_cnf(T_TCPIP_CLOSE_CNF *tcpip_close_cnf,
  476. T_SOCK_API_INSTANCE api_instance)
  477. {
  478. T_SOCK_SOCKET_DATA* sock_data;
  479. T_SOCK_CLOSE_CNF sock_close_cnf;
  480. T_SOCK_API_INSTANCE_DATA *api_data;
  481. TRACE_FUNCTION("[Socket API] sock_close_cnf()");
  482. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  483. sock_data = FindSocketData(api_data ,tcpip_close_cnf->socket);
  484. if(sock_data == NULL)
  485. {
  486. PFREE(tcpip_close_cnf);
  487. return;
  488. }
  489. /* fill confirm struct */
  490. sock_close_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_close_cnf->event_type;
  491. sock_close_cnf.result = (T_SOCK_RESULT)tcpip_close_cnf->result;
  492. sock_close_cnf.socket = (T_SOCK_SOCKET)sock_data;
  493. sock_data->callback(&sock_close_cnf, sock_data->context);
  494. /* release socket data if sock closing was successful */
  495. if(tcpip_close_cnf->result == TCPIP_RESULT_OK)
  496. {
  497. ReleaseSocketData(sock_data->api_data, sock_data);
  498. }
  499. PFREE(tcpip_close_cnf);
  500. }/* sock_close_cnf */
  501. /******************************************************************************/
  502. T_SOCK_RESULT sock_bind(T_SOCK_SOCKET socket, T_SOCK_PORT port)
  503. {
  504. T_SOCK_API_INSTANCE_DATA* api_data;
  505. T_SOCK_SOCKET_DATA *sock_data;
  506. TRACE_FUNCTION("[Socket API] sock_bind()");
  507. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  508. if(sock_data == NULL)
  509. {
  510. return SOCK_RESULT_INVALID_PARAMETER;
  511. }
  512. api_data = sock_data->api_data;
  513. {
  514. PALLOC (tcpip_bind_req_prim, TCPIP_BIND_REQ);
  515. tcpip_bind_req_prim->app_handle = api_data->hCommAPP;
  516. tcpip_bind_req_prim->socket = sock_data->tcpip_socket;
  517. tcpip_bind_req_prim->port = port;
  518. PSEND(api_data->hCommTCPIP, tcpip_bind_req_prim);
  519. }
  520. return SOCK_RESULT_OK;
  521. }/* sock_bind */
  522. /*******************************************************************************
  523. ** Function : sock_bind_cnf
  524. ** Parameter : T_SOCK_BIND_CNF *
  525. ** T_SOCK_API_INSTANCE
  526. *******************************************************************************/
  527. LOCAL void sock_bind_cnf(T_TCPIP_BIND_CNF *tcpip_bind_cnf,
  528. T_SOCK_API_INSTANCE api_instance)
  529. {
  530. T_SOCK_SOCKET_DATA *sock_data;
  531. T_SOCK_BIND_CNF sock_bind_cnf;
  532. T_SOCK_API_INSTANCE_DATA *api_data;
  533. TRACE_FUNCTION("[Socket API] sock_bind_cnf()");
  534. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  535. sock_data = FindSocketData(api_data ,tcpip_bind_cnf->socket);
  536. if(sock_data == NULL)
  537. {
  538. PFREE(tcpip_bind_cnf);
  539. return;
  540. }
  541. /* fill confirm struct */
  542. sock_bind_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_bind_cnf->event_type;
  543. sock_bind_cnf.result = (T_SOCK_RESULT)tcpip_bind_cnf->result;
  544. sock_bind_cnf.socket = (T_SOCK_SOCKET)sock_data;
  545. sock_data->callback(&sock_bind_cnf,sock_data->context);
  546. PFREE(tcpip_bind_cnf);
  547. }/* sock_bind_cnf */
  548. /******************************************************************************/
  549. T_SOCK_RESULT sock_listen(T_SOCK_SOCKET socket )
  550. {
  551. T_SOCK_API_INSTANCE_DATA* api_data;
  552. T_SOCK_SOCKET_DATA* sock_data;
  553. TRACE_FUNCTION("[Socket API] sock_listen()");
  554. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  555. if(sock_data == NULL)
  556. {
  557. TRACE_ERROR("[Socket API] listen() error: Invalid socket data");
  558. return SOCK_RESULT_INVALID_PARAMETER;
  559. }
  560. api_data = sock_data->api_data;
  561. {
  562. PALLOC (tcpip_listen_req_prim, TCPIP_LISTEN_REQ);
  563. tcpip_listen_req_prim->app_handle = api_data->hCommAPP;
  564. tcpip_listen_req_prim->socket = sock_data->tcpip_socket;
  565. PSEND(api_data->hCommTCPIP,tcpip_listen_req_prim );
  566. }
  567. return SOCK_RESULT_OK;
  568. }/* sock_listen */
  569. /*******************************************************************************
  570. ** Function : sock_listen_cnf
  571. ** Parameter : T_SOCK_LISTEN_CNF *
  572. ** T_SOCK_API_INSTANCE
  573. *******************************************************************************/
  574. LOCAL void sock_listen_cnf(T_TCPIP_LISTEN_CNF *tcpip_listen_cnf,
  575. T_SOCK_API_INSTANCE api_instance )
  576. {
  577. T_SOCK_SOCKET_DATA *sock_data;
  578. T_SOCK_LISTEN_CNF sock_listen_cnf;
  579. T_SOCK_API_INSTANCE_DATA *api_data;
  580. TRACE_FUNCTION("[Socket API] sock_listen_cnf()");
  581. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  582. sock_data = FindSocketData(api_data ,tcpip_listen_cnf->socket);
  583. if(sock_data == NULL)
  584. {
  585. PFREE(tcpip_listen_cnf);
  586. return;
  587. }
  588. /* fill confirm struct */
  589. sock_listen_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_listen_cnf->event_type;
  590. sock_listen_cnf.result = (T_SOCK_RESULT)tcpip_listen_cnf->result;
  591. sock_listen_cnf.socket = (T_SOCK_SOCKET)sock_data;
  592. sock_data->callback(&sock_listen_cnf,sock_data->context);
  593. PFREE(tcpip_listen_cnf);
  594. } /* sock_listen_cnf */
  595. /******************************************************************************/
  596. T_SOCK_RESULT sock_connect(T_SOCK_SOCKET socket,
  597. T_SOCK_IPADDR ipaddr,
  598. T_SOCK_PORT port)
  599. {
  600. T_SOCK_API_INSTANCE_DATA* api_data;
  601. T_SOCK_SOCKET_DATA* sock_data;
  602. TRACE_FUNCTION("sock_connect()");
  603. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  604. if(sock_data == NULL)
  605. {
  606. TRACE_ERROR("[Socket API] connect error: Invalid socket data");
  607. return SOCK_RESULT_INVALID_PARAMETER;
  608. }
  609. api_data = sock_data->api_data;
  610. {
  611. PALLOC (tcpip_connect_req_prim, TCPIP_CONNECT_REQ);
  612. tcpip_connect_req_prim->app_handle = api_data->hCommAPP;
  613. tcpip_connect_req_prim->socket = sock_data->tcpip_socket;
  614. tcpip_connect_req_prim->ipaddr = ipaddr;
  615. tcpip_connect_req_prim->port = port;
  616. PSEND(api_data->hCommTCPIP, tcpip_connect_req_prim);
  617. }
  618. return SOCK_RESULT_OK;
  619. } /* sock_connect */
  620. /*******************************************************************************
  621. ** Function : sock_connect_cnf
  622. ** Parameter : T_SOCK_CONNECT_CNF *
  623. ** T_SOCK_API_INSTANCE
  624. *******************************************************************************/
  625. LOCAL void sock_connect_cnf(T_TCPIP_CONNECT_CNF *tcpip_connect_cnf,
  626. T_SOCK_API_INSTANCE api_instance )
  627. {
  628. T_SOCK_SOCKET_DATA *sock_data;
  629. T_SOCK_CONNECT_CNF sock_connect_cnf;
  630. T_SOCK_API_INSTANCE_DATA *api_data;
  631. TRACE_FUNCTION("sock_connect_cnf()");
  632. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  633. TRACE_EVENT_P3("api_data %d, socket %d, reslut %d",api_data,
  634. tcpip_connect_cnf->socket,tcpip_connect_cnf->result);
  635. sock_data = FindSocketData(api_data ,tcpip_connect_cnf->socket);
  636. if(sock_data == NULL)
  637. {
  638. TRACE_EVENT("sock data NULL !!!");
  639. PFREE(tcpip_connect_cnf);
  640. return;
  641. }
  642. /* fill confirm struct */
  643. sock_connect_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_connect_cnf->event_type;
  644. sock_connect_cnf.result = (T_SOCK_RESULT)tcpip_connect_cnf->result;
  645. sock_connect_cnf.socket = (T_SOCK_SOCKET)sock_data;
  646. sock_data->callback(&sock_connect_cnf,sock_data->context);
  647. PFREE(tcpip_connect_cnf);
  648. } /* sock_connect_cnf */
  649. /******************************************************************************/
  650. T_SOCK_RESULT sock_getsockname(T_SOCK_SOCKET socket)
  651. {
  652. T_SOCK_API_INSTANCE_DATA* api_data;
  653. T_SOCK_SOCKET_DATA* sock_data;
  654. TRACE_FUNCTION("sock_getsockname()");
  655. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  656. if(sock_data == NULL)
  657. {
  658. TRACE_ERROR("[Socket API] getsockname() error: Invalid socket data");
  659. return SOCK_RESULT_INVALID_PARAMETER;
  660. }
  661. api_data = sock_data->api_data;
  662. {
  663. PALLOC(tcpip_sockname_req_prim, TCPIP_SOCKNAME_REQ);
  664. tcpip_sockname_req_prim->app_handle = api_data->hCommAPP;
  665. tcpip_sockname_req_prim->socket = sock_data->tcpip_socket;
  666. PSEND(api_data->hCommTCPIP, tcpip_sockname_req_prim);
  667. }
  668. return SOCK_RESULT_OK;
  669. } /* sock_getsockname */
  670. /*******************************************************************************
  671. ** Function : sock_connect_cnf
  672. ** Parameter : T_SOCK_SOCKNAME_CNF *
  673. ** T_SOCK_API_INSTANCE
  674. *******************************************************************************/
  675. LOCAL void sock_sockname_cnf(T_TCPIP_SOCKNAME_CNF *tcpip_sockname_cnf,
  676. T_SOCK_API_INSTANCE api_instance )
  677. {
  678. T_SOCK_SOCKET_DATA *sock_data;
  679. T_SOCK_SOCKNAME_CNF sock_sockname_cnf;
  680. T_SOCK_API_INSTANCE_DATA *api_data;
  681. TRACE_FUNCTION("sock_getsockname_cnf()");
  682. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  683. sock_data = FindSocketData(api_data , tcpip_sockname_cnf->socket);
  684. if(sock_data == NULL)
  685. {
  686. PFREE(tcpip_sockname_cnf);
  687. return;
  688. }
  689. /* fill confirm struct */
  690. sock_sockname_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_sockname_cnf->event_type;
  691. sock_sockname_cnf.result = (T_SOCK_RESULT)tcpip_sockname_cnf->result;
  692. sock_sockname_cnf.socket = (T_SOCK_SOCKET)sock_data;
  693. sock_sockname_cnf.ipaddr = tcpip_sockname_cnf->ipaddr;
  694. sock_sockname_cnf.port = tcpip_sockname_cnf->port;
  695. sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_sockname_cnf,sock_data->context);
  696. PFREE(tcpip_sockname_cnf);
  697. } /* sock_sockname_cnf */
  698. /******************************************************************************/
  699. T_SOCK_RESULT sock_getpeername(T_SOCK_SOCKET socket)
  700. {
  701. T_SOCK_API_INSTANCE_DATA* api_data;
  702. T_SOCK_SOCKET_DATA* sock_data;
  703. TRACE_FUNCTION("sock_getpeername()");
  704. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  705. api_data = sock_data->api_data;
  706. if((sock_data == NULL) OR (api_data == NULL))
  707. {
  708. TRACE_ERROR("[Socket API] getpeername() error: Invalid socket data");
  709. return SOCK_RESULT_INVALID_PARAMETER;
  710. }
  711. {
  712. PALLOC (tcpip_peername_req_prim, TCPIP_PEERNAME_REQ);
  713. tcpip_peername_req_prim->app_handle = api_data->hCommAPP;
  714. tcpip_peername_req_prim->socket = sock_data->tcpip_socket;
  715. PSEND(api_data->hCommTCPIP, tcpip_peername_req_prim);
  716. }
  717. return SOCK_RESULT_OK;
  718. } /* sock_getpeername */
  719. /*******************************************************************************
  720. ** Function : sock_peername_cnf
  721. ** Parameter : T_SOCK_PEERNAME_CNF *
  722. ** T_SOCK_API_INSTANCE
  723. *******************************************************************************/
  724. LOCAL void sock_peername_cnf(T_TCPIP_PEERNAME_CNF *tcpip_peername_cnf,
  725. T_SOCK_API_INSTANCE api_instance )
  726. {
  727. T_SOCK_SOCKET_DATA *sock_data;
  728. T_SOCK_PEERNAME_CNF sock_peername_cnf;
  729. T_SOCK_API_INSTANCE_DATA *api_data;
  730. TRACE_FUNCTION("sock_getpeername_cnf()");
  731. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  732. sock_data = FindSocketData(api_data ,tcpip_peername_cnf->socket);
  733. if(sock_data == NULL)
  734. {
  735. PFREE(tcpip_peername_cnf);
  736. return;
  737. }
  738. sock_peername_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_peername_cnf->event_type;
  739. sock_peername_cnf.result = (T_SOCK_RESULT)tcpip_peername_cnf->result;
  740. sock_peername_cnf.socket = (T_SOCK_SOCKET)sock_data;
  741. sock_peername_cnf.ipaddr = tcpip_peername_cnf->ipaddr;
  742. sock_peername_cnf.port = tcpip_peername_cnf->port;
  743. sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_peername_cnf,sock_data->context);
  744. PFREE(tcpip_peername_cnf);
  745. } /* sock_peername_cnf */
  746. /******************************************************************************/
  747. T_SOCK_RESULT sock_gethostbyname(T_SOCK_API_INSTANCE api_instance,
  748. char* hostname,
  749. T_SOCK_CALLBACK callback,
  750. void* context)
  751. {
  752. T_SOCK_API_INSTANCE_DATA* api_data;
  753. T_SOCK_SOCKET_DATA* socket_data;
  754. TRACE_FUNCTION("sock_gethostbyname()");
  755. TRACE_EVENT_P1("hostname: %s",hostname);
  756. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  757. if(callback EQ NULL)
  758. return SOCK_RESULT_INVALID_PARAMETER;
  759. if(api_data == NULL)
  760. {
  761. TRACE_ERROR("[Socket API] gethostbyname() error: Invalid socket data");
  762. return SOCK_RESULT_INVALID_PARAMETER;
  763. }
  764. MALLOC(socket_data, sizeof(T_SOCK_SOCKET_DATA));
  765. /* put socket data in linked list */
  766. socket_data->next_socket_data = api_data->socket_data;
  767. api_data->socket_data = socket_data;
  768. /* initialize socket data */
  769. socket_data->api_data = api_data;
  770. socket_data->tcpip_socket = 0;
  771. socket_data->callback = callback;
  772. socket_data->context = context;
  773. socket_data->rx_flow_control = SOCK_FLOW_XON;
  774. socket_data->tx_flow_control = SOCK_FLOW_XON;
  775. socket_data->rx_window = 1;
  776. socket_data->tx_window = 1;
  777. {
  778. PALLOC (tcpip_hostinfo_req_prim , TCPIP_HOSTINFO_REQ);
  779. tcpip_hostinfo_req_prim->app_handle = api_data->hCommAPP;
  780. tcpip_hostinfo_req_prim->ipaddr = 0;
  781. strcpy((char*)tcpip_hostinfo_req_prim->hostname, hostname);
  782. tcpip_hostinfo_req_prim->request_id = (T_SOCK_SOCKET)socket_data;
  783. PSEND(api_data->hCommTCPIP,tcpip_hostinfo_req_prim);
  784. }
  785. return SOCK_RESULT_OK;
  786. } /* sock_gethostbyname */
  787. /*******************************************************************************
  788. ** Function : sock_hostinfo_cnf
  789. ** Parameter : T_SOCK_HOSTINFO_CNF *
  790. ** T_SOCK_API_INSTANCE this value will be ignored ...
  791. ** because you can find sock_data using request_id.
  792. *******************************************************************************/
  793. LOCAL void sock_hostinfo_cnf(T_TCPIP_HOSTINFO_CNF* tcpip_hostinfo_cnf ,
  794. T_SOCK_API_INSTANCE api_instance )
  795. {
  796. T_SOCK_SOCKET_DATA* socket_data;
  797. T_SOCK_HOSTINFO_CNF sock_hostinfo_cnf;
  798. socket_data = (T_SOCK_SOCKET_DATA*)tcpip_hostinfo_cnf->request_id;
  799. /* set received values */
  800. socket_data->tcpip_socket = tcpip_hostinfo_cnf->socket;
  801. /* fill confirm struct */
  802. sock_hostinfo_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_hostinfo_cnf->event_type;
  803. sock_hostinfo_cnf.result = (T_SOCK_RESULT)tcpip_hostinfo_cnf->result;
  804. sock_hostinfo_cnf.socket = (T_SOCK_SOCKET)socket_data;
  805. sock_hostinfo_cnf.ipaddr = tcpip_hostinfo_cnf->ipaddr;
  806. strcpy(sock_hostinfo_cnf.hostname,(char*)tcpip_hostinfo_cnf->hostname);
  807. socket_data->callback((T_SOCK_EVENTSTRUCT*)&sock_hostinfo_cnf, socket_data->context);
  808. ReleaseSocketData(socket_data->api_data, socket_data);
  809. PFREE(tcpip_hostinfo_cnf);
  810. } /* sock_hostinfo_cnf */
  811. /******************************************************************************/
  812. T_SOCK_RESULT sock_send(T_SOCK_SOCKET socket, char* buffer, U16 buffer_length)
  813. {
  814. T_SOCK_API_INSTANCE_DATA* api_data;
  815. T_SOCK_SOCKET_DATA* sock_data;
  816. TRACE_FUNCTION("[Socket API] sock_send()");
  817. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  818. if(sock_data == NULL)
  819. {
  820. return SOCK_RESULT_INVALID_PARAMETER;
  821. }
  822. api_data = sock_data->api_data;
  823. if(sock_data->tx_window != 0)
  824. {
  825. PALLOC(tcpip_data_req_prim,TCPIP_DATA_REQ);
  826. tcpip_data_req_prim->app_handle = api_data->hCommAPP;
  827. tcpip_data_req_prim->socket = sock_data->tcpip_socket;
  828. tcpip_data_req_prim->ipaddr = 0;
  829. tcpip_data_req_prim->port = 0;
  830. tcpip_data_req_prim->buflen = buffer_length;
  831. tcpip_data_req_prim->data = (U32) M_ALLOC(buffer_length);
  832. if(tcpip_data_req_prim->data)
  833. {
  834. /* copy the user data buffer,
  835. the prim-data is freed by tcpip_clear_send_buffer() */
  836. memcpy((char *)tcpip_data_req_prim->data,buffer,buffer_length);
  837. }
  838. else
  839. {
  840. PFREE(tcpip_data_req_prim);
  841. return SOCK_RESULT_OUT_OF_MEMORY;
  842. }
  843. sock_data->tx_window--;
  844. PSEND(api_data->hCommTCPIP,tcpip_data_req_prim);
  845. return SOCK_RESULT_OK;
  846. }
  847. else /* tx_window = 0 */
  848. {
  849. sock_data->tx_flow_control = SOCK_FLOW_XOFF;
  850. return SOCK_RESULT_NO_BUFSPACE;
  851. }
  852. } /* sock_send */
  853. /******************************************************************************/
  854. T_SOCK_RESULT sock_sendto(T_SOCK_SOCKET socket, char* buffer,U16 buffer_length,
  855. T_SOCK_IPADDR ipaddr,T_SOCK_PORT port)
  856. {
  857. T_SOCK_API_INSTANCE_DATA* api_data;
  858. T_SOCK_SOCKET_DATA* sock_data;
  859. TRACE_FUNCTION("[Socket API] sock_sendto()");
  860. sock_data = (T_SOCK_SOCKET_DATA*)socket;
  861. if(sock_data == NULL)
  862. return SOCK_RESULT_INVALID_PARAMETER;
  863. api_data = sock_data->api_data;
  864. if(sock_data->tx_window != 0)
  865. {
  866. PALLOC(tcpip_data_req_prim,TCPIP_DATA_REQ);
  867. tcpip_data_req_prim->app_handle = api_data->hCommAPP;
  868. tcpip_data_req_prim->socket = sock_data->tcpip_socket;
  869. tcpip_data_req_prim->ipaddr = ipaddr;
  870. tcpip_data_req_prim->port = port;
  871. tcpip_data_req_prim->buflen = buffer_length;
  872. tcpip_data_req_prim->data=(U32) M_ALLOC(buffer_length);
  873. if(tcpip_data_req_prim->data )
  874. {
  875. /* copy the user data buffer,
  876. the prim-data is freed by tcpip_clear_send_buffer() */
  877. memcpy((char *)tcpip_data_req_prim->data,buffer,buffer_length);
  878. }
  879. else
  880. {
  881. PFREE(tcpip_data_req_prim);
  882. return SOCK_RESULT_OUT_OF_MEMORY;
  883. }
  884. sock_data->tx_window--;
  885. PSEND(api_data->hCommTCPIP, tcpip_data_req_prim);
  886. return SOCK_RESULT_OK;
  887. }
  888. else /* tx_window = 0 */
  889. {
  890. sock_data->tx_flow_control = SOCK_FLOW_XOFF;
  891. return SOCK_RESULT_NO_BUFSPACE;
  892. }
  893. }
  894. /*******************************************************************************
  895. ** Function : sock_mtu_size_cnf
  896. ** Parameter : T_SOCK_MTU_SIZE_CNF *
  897. ** T_SOCK_API_INSTANCE
  898. *******************************************************************************/
  899. LOCAL void sock_mtu_size_cnf(T_TCPIP_MTU_SIZE_CNF *tcpip_mtu_size_cnf ,
  900. T_SOCK_API_INSTANCE api_instance )
  901. {
  902. T_SOCK_SOCKET_DATA *sock_data;
  903. T_SOCK_MTU_SIZE_CNF sock_mtu_size_cnf;
  904. T_SOCK_API_INSTANCE_DATA *api_data;
  905. TRACE_FUNCTION("[Socket API] sock_mtu_size_cnf()");
  906. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  907. sock_data = FindSocketData(api_data ,tcpip_mtu_size_cnf->socket);
  908. if(sock_data == NULL)
  909. {
  910. PFREE(tcpip_mtu_size_cnf);
  911. return;
  912. }
  913. sock_mtu_size_cnf.event_type = (T_SOCK_EVENTTYPE)tcpip_mtu_size_cnf->event_type;
  914. sock_mtu_size_cnf.result = (T_SOCK_RESULT)tcpip_mtu_size_cnf->result;
  915. sock_mtu_size_cnf.socket = (T_SOCK_SOCKET)sock_data;
  916. sock_mtu_size_cnf.mtu_size = tcpip_mtu_size_cnf->mtu_size;
  917. sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_mtu_size_cnf,sock_data->context);
  918. PFREE(tcpip_mtu_size_cnf);
  919. } /* sock_mtu_size_cnf */
  920. /*******************************************************************************
  921. ** Function : sock_connect_ind
  922. ** Parameter : T_SOCK_CONNECT_IND *
  923. ** T_SOCK_API_INSTANCE
  924. ** Description : new socket_data will be linked to current socket_data(listening socke_data)
  925. *******************************************************************************/
  926. LOCAL void sock_connect_ind(T_TCPIP_CONNECT_IND *tcpip_connect_ind ,
  927. T_SOCK_API_INSTANCE api_instance )
  928. {
  929. T_SOCK_SOCKET_DATA *cur_sock_data; /* listening socket_data */
  930. T_SOCK_SOCKET_DATA *new_sock_data; /* connected socket_data */
  931. T_SOCK_CONNECT_IND sock_connect_ind;
  932. T_SOCK_API_INSTANCE_DATA *api_data;
  933. TRACE_FUNCTION("[Socket API] sock_connect_ind()");
  934. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  935. /* find listening socket_data
  936. * tcpip_connent_ind->socket is listening socket descrpitor
  937. */
  938. cur_sock_data = FindSocketData(api_data ,tcpip_connect_ind->socket);
  939. if(cur_sock_data == NULL)
  940. {
  941. PFREE(tcpip_connect_ind);
  942. return;
  943. }
  944. /* allocate socket data */
  945. MALLOC(new_sock_data, sizeof(T_SOCK_SOCKET_DATA));
  946. /* put socket data in linked list */
  947. new_sock_data->next_socket_data = NULL;
  948. cur_sock_data->next_socket_data = new_sock_data;
  949. /* initialize socket data */
  950. new_sock_data->api_data = api_data;
  951. new_sock_data->tcpip_socket = tcpip_connect_ind->new_socket;
  952. /* server must register callback using socket_get_callback() after receiving */
  953. /* connect ind event. */
  954. new_sock_data->callback = NULL;
  955. new_sock_data->context = NULL;
  956. new_sock_data->rx_flow_control = SOCK_FLOW_XON;
  957. new_sock_data->tx_flow_control = SOCK_FLOW_XON;
  958. new_sock_data->rx_window = 1;
  959. new_sock_data->tx_window = 1;
  960. /* fill confirm struct */
  961. sock_connect_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_connect_ind->event_type;
  962. sock_connect_ind.result = (T_SOCK_RESULT)tcpip_connect_ind->result;
  963. /* Check !!! why cur_sock data become new_sock_data */
  964. /* sock_connect_ind.socket = (T_SOCK_SOCKET)cur_sock_data;*/
  965. sock_connect_ind.socket = (T_SOCK_SOCKET)new_sock_data;
  966. sock_connect_ind.new_socket = tcpip_connect_ind->new_socket;
  967. sock_connect_ind.peer_ipaddr = tcpip_connect_ind->ipaddr;
  968. sock_connect_ind.peer_port = tcpip_connect_ind->port;
  969. cur_sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_connect_ind,cur_sock_data->context);
  970. PFREE(tcpip_connect_ind);
  971. } /* sock_connect_ind */
  972. /*******************************************************************************
  973. ** Function : sock_conn_closed_ind
  974. ** Parameter : T_SOCK_CONN_CLOSED_IND *
  975. ** T_SOCK_API_INSTANCE
  976. ** Release closed socket data
  977. *******************************************************************************/
  978. LOCAL void sock_conn_closed_ind(T_TCPIP_CONN_CLOSED_IND *tcpip_conn_closed_ind,
  979. T_SOCK_API_INSTANCE api_instance)
  980. {
  981. T_SOCK_SOCKET_DATA *sock_data;
  982. T_SOCK_CONN_CLOSED_IND sock_conn_closed_ind;
  983. T_SOCK_API_INSTANCE_DATA *api_data;
  984. TRACE_FUNCTION("[Socket API] sock_closed_ind()");
  985. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  986. sock_data = FindSocketData(api_data, tcpip_conn_closed_ind->socket);
  987. if(sock_data != NULL)
  988. {
  989. sock_conn_closed_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_conn_closed_ind->event_type;
  990. sock_conn_closed_ind.result = (T_SOCK_RESULT)tcpip_conn_closed_ind->result;
  991. sock_conn_closed_ind.socket = (T_SOCK_SOCKET)sock_data;
  992. sock_data->callback(&sock_conn_closed_ind,sock_data->context);
  993. ReleaseSocketData(sock_data->api_data,sock_data);
  994. }
  995. else {;}
  996. PFREE(tcpip_conn_closed_ind);
  997. } /* sock_conn_closed_ind */
  998. /*******************************************************************************
  999. ** Function : sock_error_ind
  1000. ** Parameter : T_SOCK_ERROR_IND *
  1001. ** T_SOCK_API_INSTANCE
  1002. *******************************************************************************/
  1003. LOCAL void sock_error_ind(T_TCPIP_ERROR_IND* tcpip_error_ind ,
  1004. T_SOCK_API_INSTANCE api_instance)
  1005. {
  1006. T_SOCK_SOCKET_DATA* sock_data;
  1007. T_SOCK_ERROR_IND sock_error_ind;
  1008. T_SOCK_API_INSTANCE_DATA *api_data;
  1009. TRACE_FUNCTION("[Socket API] sock_error_ind()");
  1010. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  1011. sock_data = FindSocketData(api_data , tcpip_error_ind->socket);
  1012. if(sock_data != NULL)
  1013. {
  1014. /* fill confirm struct */
  1015. sock_error_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_error_ind->event_type;
  1016. sock_error_ind.result = (T_SOCK_RESULT)tcpip_error_ind->result;
  1017. sock_error_ind.socket = (T_SOCK_SOCKET)sock_data;
  1018. sock_data->callback(&sock_error_ind,sock_data->context);
  1019. }
  1020. else {;}
  1021. PFREE(tcpip_error_ind);
  1022. } /* sock_error_ind */
  1023. /******************************************************************************/
  1024. T_SOCK_RESULT sock_gethostbyaddr(T_SOCK_API_INSTANCE api_instance,
  1025. T_SOCK_IPADDR ipaddr,
  1026. T_SOCK_CALLBACK callback,
  1027. void* context )
  1028. {
  1029. T_SOCK_API_INSTANCE_DATA* api_data;
  1030. T_SOCK_SOCKET_DATA* socket_data;
  1031. TRACE_FUNCTION("[Socket API] sock_gethostbyaddr()");
  1032. if(callback EQ NULL)
  1033. return SOCK_RESULT_INVALID_PARAMETER;
  1034. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  1035. MALLOC(socket_data, sizeof(T_SOCK_SOCKET_DATA));
  1036. /* put socket data in linked list */
  1037. socket_data->next_socket_data = api_data->socket_data;
  1038. api_data->socket_data = socket_data;
  1039. /* initialize socket data */
  1040. socket_data->api_data = api_data;
  1041. socket_data->tcpip_socket = 0;
  1042. socket_data->callback = callback;
  1043. socket_data->context = context;
  1044. socket_data->rx_flow_control = SOCK_FLOW_XON;
  1045. socket_data->tx_flow_control = SOCK_FLOW_XON;
  1046. socket_data->rx_window = 1;
  1047. socket_data->tx_window = 1;
  1048. {
  1049. PALLOC (tcpip_hostinfo_req_prim ,TCPIP_HOSTINFO_REQ);
  1050. tcpip_hostinfo_req_prim->app_handle = api_data->hCommAPP;
  1051. tcpip_hostinfo_req_prim->ipaddr = ipaddr;
  1052. *tcpip_hostinfo_req_prim->hostname = 0;
  1053. tcpip_hostinfo_req_prim->request_id = (T_SOCK_SOCKET)socket_data;
  1054. PSEND(api_data->hCommTCPIP, tcpip_hostinfo_req_prim);
  1055. }
  1056. return SOCK_RESULT_OK;
  1057. } /* sock_gethostbyaddr */
  1058. /*******************************************************************************
  1059. Function : sock_recv_ind
  1060. Parameter : T_TCPIP_DATA_IND*
  1061. T_SOCK_API_INSTANCE
  1062. Return : VOID
  1063. Return Event : None
  1064. *******************************************************************************/
  1065. static void sock_recv_ind(T_TCPIP_DATA_IND* tcpip_data_ind,
  1066. T_SOCK_API_INSTANCE api_instance)
  1067. {
  1068. T_SOCK_SOCKET_DATA* sock_data;
  1069. T_SOCK_RECV_IND sock_receive_ind;
  1070. T_SOCK_API_INSTANCE_DATA *api_data;
  1071. TRACE_FUNCTION("[Socket API] sock_recv_ind()");
  1072. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  1073. sock_data = FindSocketData(api_data , tcpip_data_ind->socket);
  1074. if(sock_data == NULL)
  1075. {
  1076. MFREE(tcpip_data_ind->data);
  1077. PFREE(tcpip_data_ind);
  1078. return;
  1079. }
  1080. sock_data->rx_window--; /* when data received, window size will be descreased..*/
  1081. if(sock_data->rx_flow_control == SOCK_FLOW_XOFF )
  1082. {
  1083. /* case sock flow xoff, sock_data will be stored and send to the application
  1084. with sock_flow_xon() */
  1085. sock_data->recv_ind.socket = tcpip_data_ind->socket;
  1086. sock_data->recv_ind.result = (T_SOCK_RESULT)tcpip_data_ind->result;
  1087. sock_data->recv_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_data_ind->event_type;
  1088. sock_data->recv_ind.data_length = tcpip_data_ind->buflen;
  1089. sock_data->recv_ind.data_buffer = (char*)tcpip_data_ind->data;
  1090. }
  1091. else
  1092. {
  1093. /* case sock flow xon , sock_data will be sent to application...*/
  1094. sock_receive_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_data_ind->event_type;
  1095. sock_receive_ind.result = (T_SOCK_RESULT)tcpip_data_ind->result;
  1096. sock_receive_ind.socket = (T_SOCK_SOCKET)sock_data;
  1097. sock_receive_ind.data_length = tcpip_data_ind->buflen;
  1098. sock_receive_ind.data_buffer = (char *)tcpip_data_ind->data;
  1099. sock_data->callback((T_SOCK_EVENTSTRUCT*)&sock_receive_ind,sock_data->context);
  1100. /* send primitive */
  1101. if( (sock_data->rx_flow_control != SOCK_FLOW_XOFF) &&
  1102. (sock_data->rx_window == 0) )
  1103. {
  1104. PALLOC(tcpip_data_res_prim,TCPIP_DATA_RES);
  1105. tcpip_data_res_prim->app_handle = api_data->hCommAPP;
  1106. ACI_ASSERT(sock_data->tcpip_socket == tcpip_data_ind->socket);
  1107. tcpip_data_res_prim->socket = tcpip_data_ind->socket ;
  1108. tcpip_data_res_prim->window = 1;
  1109. sock_data->rx_window = 1;
  1110. PSEND(api_data->hCommTCPIP, tcpip_data_res_prim);
  1111. }
  1112. }
  1113. PFREE(tcpip_data_ind);
  1114. } /* sock_recv_ind */
  1115. /*******************************************************************************
  1116. ** Function : sock_send_cnf
  1117. ** Parameter : T_TCPIP_DATA_CNF *
  1118. ** T_SOCK_API_INSTANCE
  1119. *******************************************************************************/
  1120. static void sock_send_cnf(T_TCPIP_DATA_CNF* tcpip_data_cnf,
  1121. T_SOCK_API_INSTANCE api_instance)
  1122. {
  1123. T_SOCK_SOCKET_DATA *sock_data;
  1124. T_SOCK_API_INSTANCE_DATA *api_data;
  1125. T_SOCK_FLOW_READY_IND sock_flow_ready_ind;
  1126. TRACE_FUNCTION("[Socket API] sock_send_cnf()");
  1127. api_data = (T_SOCK_API_INSTANCE_DATA*)api_instance;
  1128. sock_data = FindSocketData(api_data , tcpip_data_cnf->socket);
  1129. if(sock_data == NULL)
  1130. {
  1131. PFREE(tcpip_data_cnf);
  1132. return;
  1133. }
  1134. /* if tcpip_data_cnf->window is 0,*/
  1135. /* this value will be 1 because 0 and 1 is the same meaning in the Rnet TCPIP.*/
  1136. if( tcpip_data_cnf->window == 0 )
  1137. {
  1138. sock_data->tx_window = 1;
  1139. }
  1140. else
  1141. {
  1142. sock_data->tx_window = tcpip_data_cnf->window;
  1143. }
  1144. sock_flow_ready_ind.event_type = (T_SOCK_EVENTTYPE)tcpip_data_cnf->event_type;
  1145. sock_flow_ready_ind.re

Large files files are truncated, but you can click here to view the full file