void Keyboard::keyDown(int code)
{
if(code == 42) { shift = true; return; }
if(code == 54) { shift = true; return; }
if(code == 100) { alt = true; return; }
int c = codeToChar(code);
if(c)
events.push(c);
}
int send_token(const sip_entity* to, const TokenType toketype_)
{
char *token=(char *)malloc(sizeof(P2PAuthToken)*2);
int i=0;
char *subject;
switch(toketype_)
{
case Auth:
i=ProcessP2PAuthToken(p2pcc, token);
subject=P2PAUTH_SUBJECT;
break;
case Reauth:
i=ProcessP2PReauthToken(p2pcc, token);
subject=P2PREAUTH_SUBJECT;
break;
case Byesession:
i=ProcessP2PByeSessionToken(p2pcc, token);
subject=P2PBYESESSION_SUBJECT;
break;
case Byelink:
i=ProcessP2PByeLinkToken(p2pcc, token);
subject=P2PBYELINK_SUBJECT;
break;
default:
printf("TokenType error\n");
free(token);
return 0;
break;
}
if(i<1)
{
printf("ProcessP2PAuthToken error\n");
free(token);
return 0;
}
codeToChar(token,sizeof(P2PAuthToken)*2);
alter_message p2pauth_message;
memset(&p2pauth_message,0,sizeof(alter_message));
p2pauth_message.body=token;
p2pauth_message.method_type=METHODMESSAGE;
p2pauth_message.content_type=CONTENT_CODE;
p2pauth_message.subject=subject;
uac_send_noSessionMessage(to, &p2pauth_message);
free(token);
return 1;
}
int uac_key_nego()
{
eXosip_event_t *g_event;
osip_header_t * subject;
char to[100];
char from[100];
//key_nego 1
snprintf(to, 50,"sip:%s@%s:%s",device_info.ipc_id,device_info.server_ip,device_info.server_port);
snprintf(from, 50,"sip:%s@%s:%s",device_info.ipc_id,device_info.server_ip,device_info.server_port);
//uac_send_noSessionMessage(to,from, NULL,"this is no KEY_NAGO1 message","KEY_NAGO1\n");
sessionId id;
sip_entity target;
memset(&target,0,sizeof(target));
sprintf(target.ip, "%s", device_info.server_ip);
target.port=atoi(device_info.server_port);
sprintf(target.username, "%s", device_info.ipc_id);
alter_message invite_message;
memset(&invite_message,0,sizeof(alter_message));
invite_message.body="this is KEY_NAGO1 message";
invite_message.content_type=CONTENT_CODE;
invite_message.subject="KEY_NAGO1\n";
uac_sendInvite(&id,&target,&invite_message);
//uac_sendInvite(&id,to,"this is no KEY_NAGO1 message","text/code","KEY_NAGO1\n");
//printf("uac_sendInvite sucess\n");
uac_waitfor(&id,EXOSIP_CALL_ANSWERED,&g_event);
if(g_event==NULL)
{
printf("no response\n\n");
return 0;
}
id.cid=g_event->cid;
id.did=g_event->did;
if(g_event->type!= EXOSIP_CALL_ANSWERED )//&& g_event->type!=EXOSIP_CALL_MESSAGE_ANSWERED)
{
//if(g_event->response )
//printf("g_event->response->message:\n");
//if(g_event->response->call_id)
//printf("g_event->response->call_id->number:%s\n",g_event->response->call_id->number);
printf("g_event->type:%d\n",g_event->type);
printf("g_event->cid:%d\n",g_event->cid);
printf("not the right response\n");
return 0;
}
osip_message_t *ack = NULL;
eXosip_call_build_ack (id.did, &ack);
if(eXosip_call_send_ack (id.did, ack)!=0)
{
printf("send_ack error\n");
return 0;
}
osip_message_get_subject(g_event->response,0,&subject);
if(subject==NULL)
{
printf("no subject\n");
return 0;
}
//printf("subject->hvalue:%s\n",subject->hvalue);
if(!strcmp(subject->hvalue,"KEY_NAGO2"))
{
//do something handle the KEY_NAGO2
osip_body_t *body;
osip_message_get_body (g_event->response, 0, &body);//body
UnicastKeyNegoRequ *unicast_key_nego_requ_packet_c=(UnicastKeyNegoRequ*)malloc (sizeof(UnicastKeyNegoRequ)*2);
if(body->length < sizeof(UnicastKeyNegoRequ)*2)
{
printf("not valid length");
free(unicast_key_nego_requ_packet_c);
return 0;
}
memcpy(unicast_key_nego_requ_packet_c,body->body, sizeof(UnicastKeyNegoRequ)*2);
decodeFromChar(unicast_key_nego_requ_packet_c,sizeof(UnicastKeyNegoRequ)*2);
if(HandleUnicastKeyNegoRequest(RegisterCon, unicast_key_nego_requ_packet_c)<1)
{
printf("HandleUnicastKeyNegoRequest error\n");
free(unicast_key_nego_requ_packet_c);
return 0;
}
id.cid=g_event->cid;
id.did=g_event->did;
osip_message_t *ack = NULL;
printf("id.cid:%d id.did:%d",id.cid,id.did);
//eXosip_call_build_ack (id.did, &ack);
//eXosip_call_send_ack (id.cid, ack);
free(unicast_key_nego_requ_packet_c);
eXosip_event_free (g_event);
}
else
{
printf("not KEY_NAGO2\n");
printf("g_event->cid:%d\n",g_event->cid);
eXosip_event_free (g_event);
return 0;
}
g_event=NULL;
UnicastKeyNegoResp *unicast_key_nego_resp_packet_c=(UnicastKeyNegoResp*)malloc (sizeof(UnicastKeyNegoResp)*2);
if(ProcessUnicastKeyNegoResponse(RegisterCon, unicast_key_nego_resp_packet_c)<1)
{
printf("ProcessUnicastKeyNegoResponse error\n");
free(unicast_key_nego_resp_packet_c);
return 0;
}
codeToChar(unicast_key_nego_resp_packet_c,sizeof(UnicastKeyNegoResp)*2);
//key_nego 3
alter_message key_nego_message;
memset(&key_nego_message,0,sizeof(alter_message));
key_nego_message.body=unicast_key_nego_resp_packet_c;
key_nego_message.method_type=METHODMESSAGE;
key_nego_message.content_type=CONTENT_CODE;
key_nego_message.subject="KEY_NAGO3";
if(uac_send_message(id,&key_nego_message)!=0)
{
printf("uac_send_message error\n");
free(unicast_key_nego_resp_packet_c);
return 0;
}
free(unicast_key_nego_resp_packet_c);
if(!uac_waitfor(&id,EXOSIP_CALL_MESSAGE_ANSWERED,&g_event))
{
printf("g_event->type:%d\n",g_event->type);
printf("g_event->cid:%d\n",g_event->cid);
printf("not the right response\n");
return 0;
}
if(g_event==NULL)
{
printf("no response\n\n");
return 0;
}
osip_message_get_subject(g_event->response,0,&subject);
//printf("subject->hvalue:%s",subject->hvalue);
if(!strcmp(subject->hvalue,"KEY_NAGO4"))
{
//do something handle the KEY_NAGO 4
osip_body_t *body;
osip_message_get_body (g_event->response, 0, &body);
UnicastKeyNegoConfirm *unicast_key_nego_confirm_packet_c=(UnicastKeyNegoConfirm*)malloc (sizeof(UnicastKeyNegoConfirm)*2);
if(body->length < sizeof(UnicastKeyNegoConfirm)*2)
{
printf("not valid length");
free(unicast_key_nego_confirm_packet_c);
eXosip_event_free (g_event);
return 0;
}
memcpy(unicast_key_nego_confirm_packet_c,body->body, sizeof(UnicastKeyNegoConfirm)*2);
//free(body);
decodeFromChar(unicast_key_nego_confirm_packet_c,sizeof(UnicastKeyNegoConfirm)*2);
if(HandleUnicastKeyNegoConfirm(RegisterCon, unicast_key_nego_confirm_packet_c)<1)
{
printf("HandleUnicastKeyNegoConfirm error\n");
free(unicast_key_nego_confirm_packet_c);
eXosip_event_free (g_event);
return 0;
}
free(unicast_key_nego_confirm_packet_c);
eXosip_event_free (g_event);
uac_bye(id);
//return 1;
}
else
{
printf("not KEY_NAGO4\n");
//printf("g_event->cid:%d\n",g_event->cid);
eXosip_event_free (g_event);
uac_bye(id);
return 0;
}
//if it is NVR , it will wait for IPC access
//if(!strcmp(device_info.ipc_port,"5063"))
//{
//user_type=NVR;
//printf("user_type is NVR\n");
//}
/*
if(user_type==NVR)
{
eXosip_event_t *event;
uac_waitfor(NULL, EXOSIP_MESSAGE_NEW,&event);
if(event==NULL)
{
printf("not the right response\n");
return 0;
}
if(HandleP2PKeyDistribution_request(event)<1)
{
printf("HandleP2PKeyDistribution_request error\n");
return 0;
}
}
*/
printf("uac_key_nego-----finished\n");
return 1;
}
int uac_register()
{
int expires=3600; /* 注册存活时间 */
int ret = 0; /* 注册返回值 */
eXosip_event_t *je = NULL; /* 监听到的消息指针 */
osip_message_t *reg = NULL; /* 注册的消息体指针 */
char from[100];/*sip:主叫用户名@被叫IP地址*/
char proxy[100];/*sip:被叫IP地址:被叫IP端口*/
memset(from, 0, 100);
memset(proxy, 0, 100);
sprintf(from, "sip:%s@%s", device_info.ipc_id, device_info.server_ip);
sprintf(proxy, "sip:%s:%s", device_info.server_ip, device_info.server_port);
/*------step 1-----------发送不带认证信息的注册请求-----------------------*/
retry:
eXosip_lock();
g_register_id = eXosip_register_build_initial_register(from, proxy, NULL, expires, ®);
char mac[12];
memset(mac,0,12);
memcpy(mac,RegisterCon->self_MACaddr.macaddr,sizeof(RegisterCon->self_MACaddr.macaddr));
//mac[12]='\n';
//getNetInfo(NULL,mac);//printf("mac:%02x %02x %02x %02x %02x %02x",mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);
codeToChar(mac,sizeof(mac));
char mac_subject[20];
sprintf(mac_subject,"MAC:%s\r\n",mac);
osip_message_set_subject(reg,mac_subject);
osip_message_set_authorization(reg, "Capability algorithm=\"H:MD5\"");
if (0 > g_register_id)
{
eXosip_lock();
printf("eXosip_register_build_initial_register error!\r\n");
return -1;
}
printf("eXosip_register_build_initial_register success!\r\n");
ret = eXosip_register_send_register(g_register_id, reg);
eXosip_unlock();
if (0 != ret)
{
printf("eXosip_register_send_register no authorization error!\r\n");
return -1;
}
printf("eXosip_register_send_register no authorization success!\r\n");
printf("g_register_id=%d\r\n", g_register_id);
for (;;)
{
je = eXosip_event_wait(10, 500);/*侦听消息的到来*/
if (NULL == je)/*没有接收到消息*/
{
continue;
}
if (EXOSIP_REGISTRATION_FAILURE == je->type)/*注册失败*/
{
printf("<EXOSIP_REGISTRATION_FAILURE>\r\n");
printf("je->rid=%d\r\n", je->rid);
/*-------step 2---------收到服务器返回的注册失败/401未认证状态------------*/
if ((NULL != je->response)&&(401 == je->response->status_code))
{
AuthActive * auth_active_packet_data=NULL;
osip_body_t *body;
osip_header_t * subject;
osip_message_get_subject(je->response,0,&subject);
if(subject==NULL)
{
printf("no subject\n");
return 0;
}
//printf("subject->hvalue:%s\n",subject->hvalue);
char mac[12];
memset(mac, 0, 12);
memcpy(mac,subject->hvalue,4);
if(!strcmp(mac,"MAC:"))
{
memcpy(mac,subject->hvalue+4,12);
decodeFromChar(mac,12);
memcpy(RegisterCon->peer_MACaddr.macaddr,mac,6);
}
else
{
printf("subject not match\n");
return 0;
}
osip_message_get_body (je->response, 0, &body);
if(!auth_active_packet_data)
{
free(auth_active_packet_data);
auth_active_packet_data=NULL;
}
if((sizeof(AuthActive)*2)>(body->length))
{
printf("body->length is not enough");
return 0;
}
auth_active_packet_data=(AuthActive *)malloc (sizeof(AuthActive)*2);//;body->length*sizeof(char));
memset(auth_active_packet_data,0,sizeof(AuthActive)*2);
memcpy(auth_active_packet_data,body->body, sizeof(AuthActive)*2);
decodeFromChar((char*)auth_active_packet_data,sizeof(AuthActive)*2);
if(!HandleWAPIProtocolAuthActive(RegisterCon,auth_active_packet_data))
{
printf("HandleWAPIProtocolAuthActive error\n");
return 0;
}
/*
//printf("message:%s\n",message);
if(0/*when receive 401Unauthorized package，send ACK and Regester/)
{
osip_message_t *ack = NULL;
int call_id=atoi(reg->call_id->number);
printf("je->did:%d\n",je->did);
ret=eXosip_call_build_ack(je->rid,&ack);
ret=eXosip_call_send_ack(atoi(je->rid),ack);
}
*/
reg = NULL;
/*----------step 3-------------发送携带认证信息的注册请求----------------------*/
eXosip_lock();
int return_num;
return_num=eXosip_clear_authentication_info();/*清除认证信息*/
printf("return_num:%d\n",return_num);
return_num=eXosip_add_authentication_info(device_info.ipc_id, device_info.ipc_id, device_info.ipc_pwd, "MD5", NULL);/*添加主叫用户的认证信息*/
printf("return_num:%d\n",return_num);
printf("je->rid:%d expires:%d return num:%d\n",je->rid,expires,eXosip_register_build_register(je->rid, expires, ®));
//if(auth_request_packet_data!=NULL)
//{
//free(auth_request_packet_data);
//auth_request_packet_data=NULL;
//}
auth_request_packet_data=(AccessAuthRequ*)malloc(sizeof(AccessAuthRequ)*2);
memset(auth_request_packet_data,0, sizeof(AccessAuthRequ)*2);
if(ProcessWAPIProtocolAccessAuthRequest(RegisterCon,auth_active_packet_data,auth_request_packet_data)<1)
{
printf("ProcessWAPIProtocolAccessAuthRequest error\n");
return 0;
}
codeToChar((char*)auth_request_packet_data,sizeof(AccessAuthRequ)*2);
//printf("length:%d",(sizeof(AuthActive)*2));
//printf("length:%d",(sizeof(AccessAuthRequ)*2));
//printf("length:%d",(sizeof(CertificateAuthRequ)*2));
//printf("length:%d",sizeof(CertificateAuthResp)*2);
//printf("length:%d",sizeof(AccessAuthResp)*2);
printf("111\n");
if(reg==NULL)
{
printf("reg==NULL\n");
}
osip_message_set_body(reg,(char*)auth_request_packet_data,sizeof(AccessAuthRequ)*2);printf("222\n");
printf("333\n");
printf("je->rid:%d\n",je->rid);printf("444\n");
ret = eXosip_register_send_register(je->rid, reg);
eXosip_unlock();
decodeFromChar((char *)auth_request_packet_data,sizeof(AccessAuthRequ)*2);
if (0 != ret)
{
printf("eXosip_register_send_register authorization error!\r\n");
return -1;
}
printf("eXosip_register_send_register authorization success!\r\n");
eXosip_event_free (je);
//free(auth_active_packet_data);
printf("end\n");
}
else/*真正的注册失败*/
{
printf("EXOSIP_REGISTRATION_FAILURE error!\r\n");
eXosip_event_free (je);
return -1;
//goto retry;/*重新注册*/
}
}
else if (EXOSIP_REGISTRATION_SUCCESS == je->type)
{printf("recieve EXOSIP_REGISTRATION_SUCCESS\n");
/*---------step 6-------------收到服务器返回的注册成功--------------------------------*/
AccessAuthResp * access_auth_resp_data;
osip_body_t *body;
osip_message_get_body (je->response, 0, &body);
if(body==NULL)
{
printf("body==NULL\n");
return 0;
}
if( body->length<sizeof(AccessAuthResp)*2)
{
printf("message length is too short:%d\n",body->length);
return 0;
}
access_auth_resp_data=(AccessAuthResp *)malloc (body->length*sizeof(char));
memcpy(access_auth_resp_data,body->body, body->length);
decodeFromChar((char*)access_auth_resp_data,sizeof(AccessAuthResp)*2);
if(auth_request_packet_data==NULL)
{
printf("auth_request_packet_data = NULL\n");
}
if(HandleWAPIProtocolAccessAuthResp(RegisterCon,auth_request_packet_data,access_auth_resp_data)<1)
{
printf("HandleWAPIProtocolAccessAuthResp error\n");
return 0;
}
g_register_id = je->rid;/*保存注册成功的注册ID*/
printf("g_register_id=%d\r\n", g_register_id);
printf("<EXOSIP_REGISTRATION_SUCCESS>\r\n");
/*
//send key agreement package 发送密钥协商包
osip_message_t * inforequest;
ret=eXosip_message_build_request(&inforequest,"MESSAGE",proxy,from,NULL);
ret=osip_message_set_body(inforequest,"sssss",6);
ret=eXosip_message_send_request(inforequest);
*/
eXosip_event_free (je);
free(auth_request_packet_data);
free(access_auth_resp_data);
return 1;
break;
}
}
return 0;
}
int main(void){
WSADATA wsaData;
SOCKET ListenSocket = INVALID_SOCKET ;
SOCKET clientSocket = INVALID_SOCKET;
struct sockaddr_in server;
char buffer[MAX_BUFF];
//Initializing WSA
if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
printf("Failed to initialize: %d\n", WSAGetLastError());
return 1;
}
printf("WSAstartup() success.\n");
//creating the socket to listen on
ListenSocket = socket(AF_INET, SOCK_STREAM, 0);
if (ListenSocket == INVALID_SOCKET) {
printf("Failed to create socket: %d\n", WSAGetLastError());
WSACleanup();
return 1;
}
printf("socket() success.\n");
// preparing sockaddr_in structure
server.sin_family = AF_INET;
server.sin_addr.s_addr = inet_addr(DEFAULT_IP);
server.sin_port = htons(DEFAULT_PORT);
//binding to socket
if (bind(ListenSocket, (struct sockaddr *)&server, sizeof(server)) == SOCKET_ERROR) {
printf("Failed to bind: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
printf("bind() success.\n");
//Listen for connection
if (listen(ListenSocket, SOMAXCONN) == SOCKET_ERROR) {
printf("Listen error: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
printf("Listen() success.\n");
// accept connection from user
clientSocket = accept(ListenSocket, NULL, NULL);
if (clientSocket == INVALID_SOCKET) {
printf("Failed to accept connection: %d\n", WSAGetLastError());
closesocket(ListenSocket);
WSACleanup();
return 1;
}
printf("Accept() success.\n");
//recieve data
int iResult;
do {
iResult = recv(clientSocket, buffer, MAX_BUFF, 0);
if (iResult > 0) {
codeToChar(buffer[0]);
}
else if (iResult == 0){
printf("Connection closed");
}
else {
printf("recv failed %d\n", WSAGetLastError());
}
} while (iResult > 0);
return 0;
}
