static void uartadapter_uart_rx_handle(void* param)
{
char *rxbuf = NULL;
int ret =0;
int read_len = 0;
rxbuf = pvPortMalloc(UA_UART_FRAME_LEN);
if(NULL == rxbuf){
ua_printf(UA_ERROR, "TCP: Allocate rx buffer failed.\n");
return;
}
while(xSemaphoreTake(ua_uart_action_sema, portMAX_DELAY) == pdTRUE){
if(ua_debug_print_en) {
//ua_printf(UA_INFO, "uartadapter_uart_thread_handle loop!");
}
ret = uartadapter_uart_recv_data();
if(ret == -1){
ua_printf(UA_ERROR, "uart recv data error!");
}else{
read_len = uartadapter_uart_read(rxbuf, UA_UART_FRAME_LEN);
if(read_len > 0){
uartadapter_tcpsend(rxbuf, read_len, 0);
}else if(read_len < 0){
ua_printf(UA_ERROR, "tcp send read_len = %d", read_len);
}
}
}
}
int uartadapter_flashwrite(int flashadd, char *pbuf, int len)
{
int ret = 0;
flash_t flash;
if( len == 0){
ua_printf(UA_ERROR, "inpua error,data length should not be null!");
ret = -1;
return ret;
}
else //as 8711am only canbe r/w in words.so make len is 4-bytes aligmented.
len += 4 - ((len%4)==0 ? 4 : (len%4));
while(len){
if(flash_write_word(&flash, flashadd, *(unsigned int *)pbuf) !=1 ){
ua_printf(UA_ERROR, "write flash error!");
ret = -1;
return ret;
}
len -= 4;
pbuf += 4;
flashadd += 4;
}
return ret;
}
void uartadapter_tcp_control_listen_fd_handler(int old_control_fd)
{
struct sockaddr_in sAddr;
int addrlen = sizeof(sAddr);
ua_tcp_control_fd_list[0] = accept(ua_tcp_control_server_listen_fd, (struct sockaddr *)&sAddr, (socklen_t*)&addrlen);
if( ua_tcp_control_fd_list[0] < 0 ) {
ua_printf(UA_ERROR, "Accept tcp control client socket fd error");
goto EXIT;
}
ua_printf(UA_INFO, "Accept new control socket %d on port %d successfully.", ua_tcp_control_fd_list[0], sAddr.sin_port);
if(old_control_fd != -1)
{
close(old_control_fd);
ua_printf(UA_INFO, "Close old control socket %d.", old_control_fd);
old_control_fd = -1;
}
return;
EXIT:
if(ua_tcp_data_server_listen_fd != -1){
close(ua_tcp_data_server_listen_fd);
ua_tcp_data_server_listen_fd = -1;
}
}
int uartadapter_uart_read(void *read_buf, size_t size)
{
/*the same as socket*/
int ret = 0;
int read_bytes;
int pread_local,pwrite_local;
char *ptr;
ua_printf(UA_DEBUG, "==>uart adapter read uart");
if(!size || !read_buf){
ua_printf(UA_ERROR, "inpua error,size should not be null");
ret = -1;
return ret;
}
pread_local = ua_pread;
pwrite_local = ua_pwrite;
ptr = (char *)read_buf;
/*calculate how much data not read */
if(!ua_overlap){
ua_uart_recv_bytes = pwrite_local - pread_local;
}else{
ua_uart_recv_bytes = (UA_UART_RECV_BUFFER_LEN - pread_local) + pwrite_local;
}
/*decide how much data shoule copy to application*/
if(size >= ua_uart_recv_bytes ){
read_bytes = ua_uart_recv_bytes;
ret = ua_uart_recv_bytes;
}else{
read_bytes = size;
ret = size;
}
if(!ua_overlap){
memcpy(ptr, (ua_uart_recv_buf+ pread_local), read_bytes );
}else {
ua_printf(UA_DEBUG, "uart recv buf is write overlap!!");
if((pread_local + read_bytes) > UA_UART_RECV_BUFFER_LEN){
memcpy(ptr,(ua_uart_recv_buf+ pread_local),(UA_UART_RECV_BUFFER_LEN-pread_local));
memcpy(ptr+(UA_UART_RECV_BUFFER_LEN-pread_local),ua_uart_recv_buf,read_bytes-(UA_UART_RECV_BUFFER_LEN- pread_local));
}else{
memcpy(ptr,(ua_uart_recv_buf+ pread_local),read_bytes);
}
}
ua_uart_recv_bytes = 0;
if((pread_local + read_bytes) >= UA_UART_RECV_BUFFER_LEN){ //update pread
ua_pread = (pread_local + read_bytes) - UA_UART_RECV_BUFFER_LEN;
ua_overlap = 0; //clean overlap flags
}else{
ua_pread = pread_local + read_bytes;
}
return ret;
}
int uartadapter_control_process(int fd, char *pbuf, size_t size)
{
/*the same as socket*/
int ret = 0;
if(!size || !pbuf){
//ua_printf(UA_ERROR, "control data input error,please check!");
ret = -1;
return ret;
}
UA_PRINT_DATA(pbuf, size);
if(uartadapter_strncmp(pbuf, UA_CONTROL_PREFIX, 10) != 0)
{
ua_printf(UA_ERROR, "control data prefix wrong!");
return -1;
}
else
{
u8 *p = (u8*)pbuf + strlen(UA_CONTROL_PREFIX);
u8 mode = *p++;
switch(mode)
{
case UART_CTRL_MODE_SET_REQ: //AMEBA_UART-MODE-TYPE-LEN-VAL-TYPE-LEN-VAL...
{
char rsp[32] = {0}; //AMEBA_UART-MODE
u32 sz = strlen(UA_CONTROL_PREFIX);
uartadapter_control_set_req_handle(p, (size - strlen(UA_CONTROL_PREFIX)));
sprintf(rsp, UA_CONTROL_PREFIX);
*(rsp + sz) = UART_CTRL_MODE_SET_RSP;
sz ++;
sprintf(rsp + sz, "\n");
sz ++;
uartadapter_tcpsend(rsp, sz, 1);
break;
}
case UART_CTRL_MODE_GET_REQ: //AMEBA_UART-MODE-TYPE
{
char rsp[128] = {0};
u32 sz = 0;
u8 type = *p;
uartadapter_control_get_req_handle(type, (u8*)rsp, &sz);
sprintf(rsp + sz, "\n");
sz ++;
uartadapter_tcpsend(rsp, sz, 1);
break;
}
default:
ua_printf(UA_ERROR, UA_CONTROL_PREFIX": Mode (%d) not support!", mode);
break;
}
}
return 0;
}
void uartadapter_tcp_control_server_handler(void *param)
{
unsigned short port = UA_CONTROL_SOCKET_PORT;
ua_printf(UA_DEBUG, "Uart Adapter: Start Tcp Control Server!");
uartadapter_tcpserver(port, 1);
#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)
ua_printf(UA_DEBUG, "Min available stack size of %s = %d * %d bytes", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));
#endif
ua_printf(UA_DEBUG, "TCP: Tcp control server stopped!");
vTaskDelete(NULL);
}
void uartadapter_tcp_data_client_handler(void *param)
{
unsigned short port = UA_DATA_SOCKET_PORT;
ua_printf(UA_DEBUG, "Uart Adapter: Start Tcp Data Client!");
uartadapter_tcpclient(ua_tcp_server_ip, port);
#if defined(INCLUDE_uxTaskGetStackHighWaterMark) && (INCLUDE_uxTaskGetStackHighWaterMark == 1)
ua_printf(UA_DEBUG, "Min available stack size of %s = %d * %d bytes\n\r", __FUNCTION__, uxTaskGetStackHighWaterMark(NULL), sizeof(portBASE_TYPE));
#endif
ua_printf(UA_DEBUG, "TCP: Tcp data client stopped!");
vTaskDelete(NULL);
}
int uartadapter_uart_open(char *uartname, ua_uart_set_str *puartpara)
{
PinName uart_tx,uart_rx;
if(!strcmp("uart0", uartname)){
uart_tx = PA_7;
uart_rx = PA_6;
ua_uart_config[0].hal_uart_adp.BaudRate = puartpara->BaudRate;
ua_uart_config[0].hal_uart_adp.FlowControl = puartpara->FlowControl;
ua_uart_config[0].hal_uart_adp.WordLen = puartpara->number;
ua_uart_config[0].hal_uart_adp.Parity = puartpara->parity;
ua_uart_config[0].hal_uart_adp.StopBit = puartpara->StopBits;
}else{
ua_printf(UA_ERROR, "please check uart name!");
return RTW_ERROR;
}
/*initial uart */
serial_init(&ua_sobj,uart_tx,uart_rx);
serial_baud(&ua_sobj,puartpara->BaudRate);
serial_format(&ua_sobj, puartpara->number, (SerialParity)puartpara->parity, puartpara->StopBits);
/*uart irq handle*/
serial_irq_handler(&ua_sobj, uartadapter_uart_irq, (uint32_t)&ua_sobj);
serial_irq_set(&ua_sobj, RxIrq, 1);
serial_irq_set(&ua_sobj, TxIrq, 1);
return 0;
}
int uartadapter_control_set_req_handle(u8 *pbuf, u32 sz)
{
u8 *p = pbuf;
u8 type = 0, len = 0;
ua_printf(UA_DEBUG, "\n===>uartadapter_control_set_req_handle()");
UA_PRINT_DATA(pbuf, sz);
while(p < (pbuf+sz)){
type = *p++;
len = *p++;
ua_printf(UA_DEBUG, "type=%d len=%d\n", type, len);
switch(type)
{
case UART_CTRL_TYPE_BAUD_RATE:
ua_uart_config[0].hal_uart_adp.BaudRate = *(u32 *)p;
ua_printf(UA_INFO, "SET UART BAUD_RATE to %d.\n", ua_uart_config[0].hal_uart_adp.BaudRate);
serial_baud(&ua_sobj, ua_uart_config[0].hal_uart_adp.BaudRate);
break;
case UART_CTRL_TYPE_WORD_LEN:
ua_uart_config[0].hal_uart_adp.WordLen = *p;
ua_printf(UA_INFO, "SET UART WORD_LEN to %d.\n", ua_uart_config[0].hal_uart_adp.WordLen);
serial_format(&ua_sobj,
ua_uart_config[0].hal_uart_adp.WordLen,
(SerialParity)ua_uart_config[0].hal_uart_adp.Parity,
ua_uart_config[0].hal_uart_adp.StopBit);
break;
case UART_CTRL_TYPE_PARITY:
ua_uart_config[0].hal_uart_adp.Parity = *p;
ua_printf(UA_INFO, "SET UART PARITY to %d.\n", ua_uart_config[0].hal_uart_adp.Parity);
serial_format(&ua_sobj,
ua_uart_config[0].hal_uart_adp.WordLen,
(SerialParity)ua_uart_config[0].hal_uart_adp.Parity,
ua_uart_config[0].hal_uart_adp.StopBit);
break;
case UART_CTRL_TYPE_STOP_BIT:
ua_uart_config[0].hal_uart_adp.StopBit = *p;
ua_printf(UA_INFO, "SET UART STOP_BIT to %d.\n", ua_uart_config[0].hal_uart_adp.StopBit);
serial_format(&ua_sobj,
ua_uart_config[0].hal_uart_adp.WordLen,
(SerialParity)ua_uart_config[0].hal_uart_adp.Parity,
ua_uart_config[0].hal_uart_adp.StopBit);
break;
case UART_CTRL_TYPE_FLOW_CTRL:
ua_uart_config[0].hal_uart_adp.FlowControl = *p;
ua_printf(UA_INFO, "SET UART FLOW_CTRL to %d.\n", ua_uart_config[0].hal_uart_adp.FlowControl);
ua_printf(UA_INFO, "SET UART FLOW_CTRL not support now.\n");
//TODO
break;
}
p += len;
}
return 0;
}
void uartadapter_tcp_control_fd_handler()
{
char tcp_rxbuf[UA_UART_FRAME_LEN];
int recv_len;
//xSemaphoreTake(ua_tcp_sema, portMAX_DELAY);
recv_len = recv(ua_tcp_control_fd_list[0], tcp_rxbuf, UA_UART_FRAME_LEN, 0); //MSG_DONTWAIT MSG_WAITALL
//xSemaphoreGive(ua_tcp_sema);
if(recv_len<0){
ua_printf(UA_ERROR, "Tcp Control Socket %d Recv Error", ua_tcp_control_fd_list[0]);
//goto EXIT;
}
ua_printf(UA_DEBUG, "Tcp Control Socket %d Recv %d Data", ua_tcp_control_fd_list[0], recv_len);
uartadapter_control_process(ua_tcp_control_fd_list[0], (void*)tcp_rxbuf, recv_len);
return;
}
void uartadapter_gpio_irq (uint32_t id, gpio_irq_event event)
{
//int ret = 0;
//int address = FAST_RECONNECT_DATA;
ua_printf(UA_DEBUG, "GPIO push button!!");
ua_gpio_irq_happen = 1;
xSemaphoreGive(ua_main_sema);
}
void uartadapter_uart_init()
{
ua_uart_set_str uartset;
ua_uart_get_str uartget;
int uartnum;
char uarttest[]="uart0";
char uartname[32] = {0};
uartset.BaudRate = 9600;
uartset.number = 8;
uartset.StopBits = 0;
uartset.FlowControl = 0;
uartset.parity = 0;
strcpy(uartset.UartName,uarttest);
uartnum = uartadapter_uart_getnum(uartname);
ua_printf(UA_DEBUG, "there is %d uart on this platform",uartnum);
ua_printf(UA_DEBUG, "uartname = %s",uartname);
uartadapter_uart_open("uart0", &uartset);
if(uartadapter_uart_getpara("uart0", &uartget))
ua_printf(UA_ERROR, "get uart failed!");
else
ua_printf(UA_DEBUG,"uart pata:\r\n"\
"uart->BaudRate = %d\r\n"\
"uart->number = %d\r\n"\
"uart->FlowControl = %d\r\n"\
"uart->parity = %d\r\n"\
"uart->StopBits = %d\r\n"\
"\r\n",\
uartget.BaudRate,\
uartget.number,\
uartget.FlowControl,\
uartget.parity,\
uartget.StopBits\
);
}
void uartadapter_tcp_data_fd_handler(char *tcp_rxbuf)
{
int recv_len;
struct ua_tcp_rx_buffer *rx_buffer;
rx_buffer = pvPortMalloc(sizeof(struct ua_tcp_rx_buffer));
if(NULL == rx_buffer){
ua_printf(UA_ERROR, "Allocate tcp data buffer failed.\n");
return;
}
//xSemaphoreTake(ua_tcp_sema, portMAX_DELAY);
recv_len = recv(ua_tcp_data_fd_list[0], tcp_rxbuf, UA_UART_FRAME_LEN, 0);
//xSemaphoreGive(ua_tcp_sema);
if(recv_len < 0){
ua_printf(UA_ERROR, "Tcp Data Socket %d Recv Error", ua_tcp_data_fd_list[0]);
//goto EXIT;
}
ua_printf(UA_DEBUG, "Tcp Data Socket %d Recv %d Data", ua_tcp_data_fd_list[0], recv_len);
#if 1
if(recv_len > 0){
memcpy(rx_buffer->data, tcp_rxbuf, recv_len);
rx_buffer->data_len = recv_len;
sys_mbox_post(&mbox_for_uart_tx, (void *)rx_buffer);
}else{
vPortFree(rx_buffer);
}
#else
uartadapter_uart_write(tcp_rxbuf, recv_len);
#endif
tcp_tx_cnt += recv_len;
return;
}
int uartadapter_tcpserver(unsigned short usPort, u8 isctrl)
{
struct sockaddr_in sLocalAddr;
int iAddrSize;
int iSockFD;
int iStatus;
iSockFD = socket(AF_INET, SOCK_STREAM, 0);
if( iSockFD < 0 ) {
ua_printf(UA_ERROR, "create server_socket error!");
goto Exit;
}
ua_printf(UA_DEBUG, "TCP: Create Tcp server socket %d", iSockFD);
//filling the TCP server socket address
memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
sLocalAddr.sin_family = AF_INET;
sLocalAddr.sin_len = sizeof(sLocalAddr);
sLocalAddr.sin_port = htons(usPort);
sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
iAddrSize = sizeof(sLocalAddr);
iStatus = bind(iSockFD, (struct sockaddr *)&sLocalAddr, iAddrSize);
if( iStatus < 0 ) {
ua_printf(UA_ERROR, "bind tcp server socket fd error! ");
goto Exit;
}
ua_printf(UA_DEBUG, "TCP: Bind successfully.");
iStatus = listen(iSockFD, 10);
if( iStatus != 0 ) {
ua_printf(UA_ERROR, "listen tcp server socket fd error!");
goto Exit;
}
ua_printf(UA_INFO, "TCP Server: Listen on port %d", usPort);
if(isctrl)
ua_tcp_control_server_listen_fd = iSockFD;
else
ua_tcp_data_server_listen_fd = iSockFD;
return 0;
Exit:
close(iSockFD);
ua_printf(UA_INFO, "Tcp server listen on port %d closed!", usPort);
return 0;
}
int uartadapter_uart_getpara(char *uart_name, ua_uart_get_str *uart_para)
{
int ret = 0;
/*get the uart para according to uart_name*/
if(!strcmp("uart0", uart_name)){
uart_para->BaudRate =ua_uart_config[0].hal_uart_adp.BaudRate;
uart_para->FlowControl =ua_uart_config[0].hal_uart_adp.FlowControl;
uart_para->number = ua_uart_config[0].hal_uart_adp.WordLen;
uart_para->parity = ua_uart_config[0].hal_uart_adp.Parity;
uart_para->StopBits = ua_uart_config[0].hal_uart_adp.StopBit;
}else{
ua_printf(UA_ERROR, "please check uart name!");
return -1;
}
return ret;
}
int uartadapter_control_get_req_handle(u8 type, u8 *prsp, u32 *sz)
{
u8 *p = prsp;
ua_printf(UA_DEBUG, "===>uartadapter_control_get_req_handle()");
sprintf((char *)p, UA_CONTROL_PREFIX);
p += strlen(UA_CONTROL_PREFIX);
*p++ = UART_CTRL_MODE_GET_RSP;
if(type & UART_CTRL_TYPE_BAUD_RATE){
*p++ = UART_CTRL_TYPE_BAUD_RATE;
*p++ = 4;
*(u32*)p = ua_uart_config[0].hal_uart_adp.BaudRate;
p += 4;
}
if(type & UART_CTRL_TYPE_WORD_LEN){
*p++ = UART_CTRL_TYPE_WORD_LEN;
*p++ = 1;
*p = ua_uart_config[0].hal_uart_adp.WordLen;
p += 1;
}
if(type & UART_CTRL_TYPE_PARITY){
*p++ = UART_CTRL_TYPE_PARITY;
*p++ = 1;
*p = ua_uart_config[0].hal_uart_adp.Parity;
p += 1;
}
if(type & UART_CTRL_TYPE_STOP_BIT){
*p++ = UART_CTRL_TYPE_STOP_BIT;
*p++ = 1;
*p = ua_uart_config[0].hal_uart_adp.StopBit;
p += 1;
}
if(type & UART_CTRL_TYPE_FLOW_CTRL){
*p++ = UART_CTRL_TYPE_FLOW_CTRL;
*p++ = 1;
*p = ua_uart_config[0].hal_uart_adp.FlowControl;
p += 1;
}
*sz = p - prsp;
UA_PRINT_DATA(prsp, *sz);
return 0;
}
void uartadapter_tcpsend(char *buffer, int size, u8 isctrl)
{
int iStatus;
ua_tcp_send_flag = 1;
if(!isctrl){
if(ua_tcp_data_fd_list[0] != -1){
//xSemaphoreTake(ua_tcp_sema, portMAX_DELAY);
iStatus = send(ua_tcp_data_fd_list[0], buffer, size, 0 );
//xSemaphoreGive(ua_tcp_sema);
if( iStatus <= 0 ){
ua_printf(UA_ERROR, "tcp data socket send data error! iStatus:%d!", iStatus);
//goto Exit;
}else if(iStatus != size){
ua_printf(UA_DEBUG, "uart tcp data socket send: size %d, ret = %d!", size, iStatus);
}
if(ua_debug_print_en){
ua_printf(UA_INFO, "uart tcp data socket send %d bytes, ret %d!", size, iStatus);
}
}
}
else{
if(ua_tcp_control_fd_list[0] != -1){
//xSemaphoreTake(ua_tcp_sema, portMAX_DELAY);
iStatus = send(ua_tcp_control_fd_list[0], buffer, size, 0 );
//xSemaphoreGive(ua_tcp_sema);
if( iStatus <= 0 ){
ua_printf(UA_ERROR,"tcp control socket send data error! iStatus:%d!", iStatus);
goto Exit;
}else if(iStatus != size){
ua_printf(UA_DEBUG,"uart tcp control socket send: size %d, ret = %d!", size, iStatus);
}
if(ua_debug_print_en){
ua_printf(UA_INFO,"uart tcp control socket send %d bytes, ret %d!", size, iStatus);
}
}
}
ua_tcp_send_flag = 0;
Exit:
return;
}
/**
* Allocate a SIP User-Agent
*
* @param uap Pointer to allocated User-Agent object
* @param aor SIP Address-of-Record (AOR)
*
* @return 0 if success, otherwise errorcode
*/
int ua_alloc(struct ua **uap, const char *aor)
{
struct ua *ua;
int err;
if (!aor)
return EINVAL;
ua = mem_zalloc(sizeof(*ua), ua_destructor);
if (!ua)
return ENOMEM;
MAGIC_INIT(ua);
list_init(&ua->calls);
#if HAVE_INET6
ua->af = uag.prefer_ipv6 ? AF_INET6 : AF_INET;
#else
ua->af = AF_INET;
#endif
/* Decode SIP address */
err = account_alloc(&ua->acc, aor);
if (err)
goto out;
/* generate a unique contact-user, this is needed to route
incoming requests when using multiple useragents */
err = re_sdprintf(&ua->cuser, "%r-%p", &ua->acc->luri.user, ua);
if (err)
goto out;
if (ua->acc->sipnat) {
ua_printf(ua, "Using sipnat: `%s'\n", ua->acc->sipnat);
}
if (ua->acc->mnat) {
ua_printf(ua, "Using medianat `%s'\n",
ua->acc->mnat->id);
if (0 == str_casecmp(ua->acc->mnat->id, "ice"))
add_extension(ua, "ice");
}
if (ua->acc->menc) {
ua_printf(ua, "Using media encryption `%s'\n",
ua->acc->menc->id);
}
/* Register clients */
if (str_isset(uag.cfg->uuid))
add_extension(ua, "gruu");
if (0 == str_casecmp(ua->acc->sipnat, "outbound")) {
size_t i;
add_extension(ua, "path");
add_extension(ua, "outbound");
if (!str_isset(uag.cfg->uuid)) {
warning("ua: outbound requires valid UUID!\n");
err = ENOSYS;
goto out;
}
for (i=0; i<ARRAY_SIZE(ua->acc->outbound); i++) {
if (ua->acc->outbound[i] && ua->acc->regint) {
err = reg_add(&ua->regl, ua, (int)i+1);
if (err)
break;
}
}
}
else if (ua->acc->regint) {
err = reg_add(&ua->regl, ua, 0);
}
if (err)
goto out;
list_append(&uag.ual, &ua->le, ua);
if (ua->acc->regint) {
err = ua_register(ua);
}
if (!uag_current())
uag_current_set(ua);
out:
if (err)
mem_deref(ua);
else if (uap) {
*uap = ua;
ua->uap = uap;
}
return err;
}
static void call_event_handler(struct call *call, enum call_event ev,
const char *str, void *arg)
{
struct ua *ua = arg;
const char *peeruri;
struct call *call2 = NULL;
int err;
MAGIC_CHECK(ua);
peeruri = call_peeruri(call);
/* stop any ringtones */
ua->play = mem_deref(ua->play);
switch (ev) {
case CALL_EVENT_INCOMING:
if (contact_block_access(peeruri)) {
info("ua: blocked access: \"%s\"\n", peeruri);
ua_event(ua, UA_EVENT_CALL_CLOSED, call, str);
mem_deref(call);
break;
}
switch (ua->acc->answermode) {
case ANSWERMODE_EARLY:
(void)call_progress(call);
break;
case ANSWERMODE_AUTO:
(void)call_answer(call, 200);
break;
case ANSWERMODE_MANUAL:
default:
if (list_count(&ua->calls) > 1) {
(void)play_file(&ua->play,
"callwaiting.wav", 3);
}
else {
/* Alert user */
(void)play_file(&ua->play, "ring.wav", -1);
}
ua_event(ua, UA_EVENT_CALL_INCOMING, call, peeruri);
break;
}
break;
case CALL_EVENT_RINGING:
(void)play_file(&ua->play, "ringback.wav", -1);
ua_event(ua, UA_EVENT_CALL_RINGING, call, peeruri);
break;
case CALL_EVENT_PROGRESS:
ua_printf(ua, "Call in-progress: %s\n", peeruri);
ua_event(ua, UA_EVENT_CALL_PROGRESS, call, peeruri);
break;
case CALL_EVENT_ESTABLISHED:
ua_printf(ua, "Call established: %s\n", peeruri);
ua_event(ua, UA_EVENT_CALL_ESTABLISHED, call, peeruri);
break;
case CALL_EVENT_CLOSED:
if (call_scode(call)) {
const char *tone;
tone = translate_errorcode(call_scode(call));
if (tone)
(void)play_file(&ua->play, tone, 1);
}
ua_event(ua, UA_EVENT_CALL_CLOSED, call, str);
mem_deref(call);
break;
case CALL_EVENT_TRANSFER:
/*
* Create a new call to transfer target.
*
* NOTE: we will automatically connect a new call to the
* transfer target
*/
ua_printf(ua, "transferring call to %s\n", str);
err = ua_call_alloc(&call2, ua, VIDMODE_ON, NULL, call,
call_localuri(call));
if (!err) {
struct pl pl;
pl_set_str(&pl, str);
err = call_connect(call2, &pl);
if (err) {
warning("ua: transfer: connect error: %m\n",
err);
}
}
if (err) {
(void)call_notify_sipfrag(call, 500, "Call Error");
mem_deref(call2);
}
break;
case CALL_EVENT_TRANSFER_FAILED:
ua_event(ua, UA_EVENT_CALL_TRANSFER_FAILED, call, str);
break;
}
}
static int uartadapter_load_wifi_config()
{
flash_t flash;
uint8_t *data;
uint32_t channel;
uint8_t pscan_config;
char key_id;
rtw_network_info_t wifi = {0};
int ret = SC_SUCCESS;
data = (uint8_t *)rtw_zmalloc(FAST_RECONNECT_DATA_LEN);
flash_stream_read(&flash, FAST_RECONNECT_DATA, FAST_RECONNECT_DATA_LEN, (uint8_t *)data);
if(*((uint32_t *) data) != ~0x0)
{
ua_printf(UA_INFO, "AP Profile read from FLASH, try to connect");
memcpy(psk_essid, (uint8_t *)data, NDIS_802_11_LENGTH_SSID + 4);
memcpy(psk_passphrase, (uint8_t *)data + NDIS_802_11_LENGTH_SSID + 4, (IW_PASSPHRASE_MAX_SIZE + 1));
memcpy(wpa_global_PSK, (uint8_t *)data + NDIS_802_11_LENGTH_SSID + 4 + (IW_PASSPHRASE_MAX_SIZE + 1), A_SHA_DIGEST_LEN * 2);
memcpy(&channel, (uint8_t *)data + NDIS_802_11_LENGTH_SSID + 4 + (IW_PASSPHRASE_MAX_SIZE + 1) + A_SHA_DIGEST_LEN * 2, 4);
sprintf(&key_id,"%d",(channel >> 28));
channel &= 0xff;
pscan_config = PSCAN_ENABLE | PSCAN_FAST_SURVEY;
//set partial scan for entering to listen beacon quickly
//wifi_set_pscan_chan((uint8_t *)&channel, &pscan_config, 1);
#ifdef CONFIG_AUTO_RECONNECT
wifi_set_autoreconnect(1);
#endif
//set wifi connect
wifi.ssid.len = (int)strlen((char*)psk_essid);
memcpy(wifi.ssid.val, psk_essid, wifi.ssid.len);
wifi.key_id = key_id;
//open mode
if(!strlen((char*)psk_passphrase)){
wifi.security_type = RTW_SECURITY_OPEN;
}
//wep mode
else if( strlen((char*)psk_passphrase) == 5 || strlen((char*)psk_passphrase) == 13){
wifi.security_type = RTW_SECURITY_WEP_PSK;
wifi.password = (unsigned char *)psk_passphrase;
wifi.password_len = (int)strlen((char const *)psk_passphrase);
}
//WPA/WPA2
else{
wifi.security_type = RTW_SECURITY_WPA2_AES_PSK;
wifi.password = (unsigned char *)psk_passphrase;
wifi.password_len = (int)strlen((char const *)psk_passphrase);
}
ret = uartadapter_connect_wifi(&wifi, channel, pscan_config);
//print_simple_config_result((enum ua_sc_result)ret);
if(data)
rtw_mfree(data, FAST_RECONNECT_DATA_LEN);
if(ret == SC_SUCCESS)
return RTW_SUCCESS;
else
return RTW_ERROR;
}else{
void uartadapter_tcp_select(void *param)
{
int max_fd;
struct timeval tv;
fd_set readfds;
int ret = 0;
char *tcp_rxbuf;
tcp_rxbuf = pvPortMalloc(UA_UART_FRAME_LEN);
if(NULL == tcp_rxbuf){
printf("\n\rTCP: Allocate client buffer failed.\n");
return;
}
while(1){
if(ua_work_thread_suspend){
ua_printf(UA_DEBUG, "uart adapter test thread suspended!");
if(xSemaphoreTake(ua_work_thread_sema, portMAX_DELAY) == TRUE)
ua_printf(UA_DEBUG, "uart adapter test thread take semaphore!");
}
FD_ZERO(&readfds);
max_fd = -1;
if(ua_tcp_data_fd_list[0] != -1){
FD_SET(ua_tcp_data_fd_list[0], &readfds);
if(ua_tcp_data_fd_list[0] > max_fd)
max_fd = ua_tcp_data_fd_list[0];
}
if(ua_tcp_control_fd_list[0] != -1){
FD_SET(ua_tcp_control_fd_list[0], &readfds);
if(ua_tcp_control_fd_list[0] > max_fd)
max_fd = ua_tcp_control_fd_list[0];
}
if(ua_tcp_control_server_listen_fd != -1){
FD_SET(ua_tcp_control_server_listen_fd, &readfds);
if(ua_tcp_control_server_listen_fd > max_fd)
max_fd = ua_tcp_control_server_listen_fd;
}
if(ua_tcp_data_server_listen_fd != -1){
FD_SET(ua_tcp_data_server_listen_fd, &readfds);
if(ua_tcp_data_server_listen_fd > max_fd)
max_fd = ua_tcp_data_server_listen_fd;
}
tv.tv_sec = 1;
tv.tv_usec = 0;
ret = select(max_fd + 1, &readfds, NULL, NULL, &tv);
if(ua_debug_print_en){
ua_printf(UA_INFO, "uart adapter test select ret = %x",ret);
}
if(ret > 0){
if(ua_tcp_data_fd_list[0] != -1 && FD_ISSET(ua_tcp_data_fd_list[0], &readfds)){
uartadapter_tcp_data_fd_handler(tcp_rxbuf);
}
if(ua_tcp_control_fd_list[0] != -1 && FD_ISSET(ua_tcp_control_fd_list[0], &readfds)){
uartadapter_tcp_control_fd_handler();
}
if(ua_tcp_data_server_listen_fd != -1 && FD_ISSET(ua_tcp_data_server_listen_fd, &readfds)){
uartadapter_tcp_data_listen_fd_handler(ua_tcp_data_fd_list[0]);
}
if(ua_tcp_control_server_listen_fd != -1 && FD_ISSET(ua_tcp_control_server_listen_fd, &readfds)){
uartadapter_tcp_control_listen_fd_handler(ua_tcp_control_fd_list[0]);
}
}
}
//vTaskDelete(NULL);
}
int uartadapter_tcpclient(const char *host_ip, unsigned short usPort)
{
int iAddrSize;
int iSockFD = -1;
int iStatus;
//int enable = 1;
struct sockaddr_in sAddr;
FD_ZERO(&sAddr);
sAddr.sin_family = AF_INET;
sAddr.sin_port = htons(usPort);
sAddr.sin_addr.s_addr = inet_addr(host_ip);
iAddrSize = sizeof(struct sockaddr_in);
iSockFD = socket(AF_INET, SOCK_STREAM, 0);
if( iSockFD < 0 ) {
ua_printf(UA_ERROR, "TCP ERROR: create tcp client socket fd error!");
return 0;
}
ua_printf(UA_DEBUG, "TCP: ServerIP=%s port=%d.", host_ip, usPort);
ua_printf(UA_DEBUG, "TCP: Create socket %d.", iSockFD);
// connecting to TCP server
iStatus = connect(iSockFD, (struct sockaddr *)&sAddr, iAddrSize);
if (iStatus < 0) {
ua_printf(UA_ERROR, "TCP ERROR: tcp client connect server error! ");
goto Exit;
}
#if 0
iStatus = setsockopt(iSockFD, IPPROTO_TCP, TCP_NODELAY, &enable, sizeof(enable));
if (iStatus < 0) {
printf("\n\rTCP ERROR: tcp client socket set opt error! ");
goto Exit;
}
#endif
ua_printf(UA_INFO, "TCP: Connect server successfully.");
#if 1
ua_work_thread_suspend = 1;
vTaskDelay(1500);
if(ua_tcp_data_fd_list[0] != -1){
ua_printf(UA_INFO, "TCP: Close old data client fd %d.", ua_tcp_data_fd_list[0]);
close(ua_tcp_data_fd_list[0]);
}
ua_tcp_data_fd_list[0] = iSockFD;
ua_printf(UA_INFO, "connect new data socket %d successfully.", iSockFD);
ua_work_thread_suspend = 0;
xSemaphoreGive(ua_work_thread_sema);
#else
ua_tcp_data_client_fd = iSockFD;
#endif
return 0;
Exit:
//ua_printf(UA_ERROR, "TCP client fd list exceed.");
close(iSockFD);
return 0;
}
