CWBool CWACSendFragments(int WTPIndex)
{
int i;
if (gWTPs[WTPIndex].messages == NULL)
return CWErrorRaise(CW_ERROR_WRONG_ARG, NULL);
for (i = 0; i < gWTPs[WTPIndex].messagesCount; i++) {
#ifdef CW_NO_DTLS
if (!CWNetworkSendUnsafeUnconnected(gWTPs[WTPIndex].socket,
&gWTPs[WTPIndex].address,
gWTPs[WTPIndex].messages[i].msg,
gWTPs[WTPIndex].messages[i].offset)) {
#else
if (!
(CWSecuritySend
(gWTPs[WTPIndex].session, gWTPs[WTPIndex].messages[i].msg, gWTPs[WTPIndex].messages[i].offset))) {
#endif
return CW_FALSE;
}
}
/*
* BUG - ML12
*
* 20/10/2009 - Donato Capitella
*/
CW_FREE_WTP_MSG_ARRAY(WTPIndex);
CWLog("Message Sent\n");
return CW_TRUE;
}
CWBool CWACResendAcknowledgedPacket(int WTPIndex)
{
if (!CWACSendFragments(WTPIndex))
return CW_FALSE;
CWThreadSetSignals(SIG_BLOCK, 1, CW_SOFT_TIMER_EXPIRED_SIGNAL);
if (!
(CWTimerRequest
(gCWRetransmitTimer, &(gWTPs[WTPIndex].thread), &(gWTPs[WTPIndex].currentPacketTimer),
CW_SOFT_TIMER_EXPIRED_SIGNAL))) {
return CW_FALSE;
}
CWThreadSetSignals(SIG_UNBLOCK, 1, CW_SOFT_TIMER_EXPIRED_SIGNAL);
return CW_TRUE;
}
__inline__ CWBool CWACSendAcknowledgedPacket(int WTPIndex, int msgType, int seqNum)
{
gWTPs[WTPIndex].retransmissionCount = 0;
gWTPs[WTPIndex].isRetransmitting = CW_TRUE;
gWTPs[WTPIndex].responseType = msgType;
gWTPs[WTPIndex].responseSeqNum = seqNum;
// CWDebugLog("~~~~~~seq num in Send: %d~~~~~~", gWTPs[WTPIndex].responseSeqNum);
return CWACResendAcknowledgedPacket(WTPIndex);
}
CW_THREAD_RETURN_TYPE CWWTPFreqManager(void *arg) {
int recSock, rlen;
struct sockaddr_in servaddr, client_addr;
socklen_t slen = sizeof(client_addr);
char buffer[PACKET_SIZE];
OFDMControlValues* freqValue;
int current_chan=0;
CWProtocolMessage *completeMsgPtr = NULL;
CWThreadSetSignals(SIG_BLOCK, 1, SIGALRM);
/* Create an Inet UDP socket for this thread (Receive freq/ack packets) */
if ((recSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
CWDebugLog("Thread Frequency Management: Error creating socket");
CWExitThread();
}
/* Set up address structure for server socket */
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
servaddr.sin_port = htons(SERVER_PORT);
/* Binding Socket */
if (bind(recSock, (struct sockaddr *) &servaddr, sizeof(struct sockaddr_in)) < 0) {
CWDebugLog("Thread Frequency Management: Binding Socket Error");
close(recSock);
CWExitThread();
}
CW_REPEAT_FOREVER /* Receive data Loop */
{
memset(buffer, 0, PACKET_SIZE);
rlen = 0;
if ( ( rlen = recvfrom(recSock, buffer, PACKET_SIZE, 0, (struct sockaddr *) &client_addr, &slen) ) > 0 )
{
freqValue = (OFDMControlValues*) buffer;
current_chan = freqValue->currentChan;
if(!CWSetCurrentChannel(current_chan)) {
CWLog("Thread Frequency Management: Failed to set current channel value.");
continue;
}
}
}
CWDebugLog("Thread Frequency Management: Thread ended unexpectedly!!");
close(recSock);
CWExitThread();
}
void CWACEnterMainLoop() {
struct sigaction act;
CWLog("AC enters in the MAIN_LOOP");
/* set signals
* all the thread we spawn will inherit these settings
*/
/*
* BUG UMR03
*
* 20/10/2009 - Donato Capitella
*/
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
/* called when a timer requested by the thread has expired */
act.sa_handler = CWCriticalTimerExpiredHandler;
sigaction(CW_CRITICAL_TIMER_EXPIRED_SIGNAL, &act, NULL);
act.sa_flags = 0;
/* called when a timer requested by the thread has expired */
act.sa_handler = CWSoftTimerExpiredHandler;
sigaction(CW_SOFT_TIMER_EXPIRED_SIGNAL, &act, NULL);
/* signals will be unblocked by the threads that needs timers */
CWThreadSetSignals(SIG_BLOCK, 2, CW_CRITICAL_TIMER_EXPIRED_SIGNAL,
CW_SOFT_TIMER_EXPIRED_SIGNAL);
if(!(CWThreadCreateSpecific(&gIndexSpecific, NULL))) {
CWLog("Critical Error With Thread Data");
exit(1);
}
CWThread thread_interface;
if(!CWErr(CWCreateThread(&thread_interface, CWInterface, NULL))) {
CWLog("Error starting Interface Thread");
exit(1);
}
CW_REPEAT_FOREVER {
/* CWACManageIncomingPacket will be called
* when a new packet is ready to be read
*/
if(!CWErr(CWNetworkUnsafeMultiHomed(&gACSocket,
CWACManageIncomingPacket,
CW_FALSE)))
exit(1);
}
}
void CWACStopRetransmission(int WTPIndex)
{
if (gWTPs[WTPIndex].isRetransmitting) {
int i;
CWDebugLog("Stop Retransmission");
gWTPs[WTPIndex].isRetransmitting = CW_FALSE;
CWThreadSetSignals(SIG_BLOCK, 1, CW_SOFT_TIMER_EXPIRED_SIGNAL);
if (!CWTimerCancel(&(gWTPs[WTPIndex].currentPacketTimer))) {
CWDebugLog("Error Cancelling a Timer... possible error!");
}
CWThreadSetSignals(SIG_UNBLOCK, 1, CW_SOFT_TIMER_EXPIRED_SIGNAL);
gWTPs[WTPIndex].responseType = UNUSED_MSG_TYPE;
gWTPs[WTPIndex].responseSeqNum = 0;
for (i = 0; i < gWTPs[WTPIndex].messagesCount; i++) {
CW_FREE_PROTOCOL_MESSAGE(gWTPs[WTPIndex].messages[i]);
}
CW_FREE_OBJECT(gWTPs[WTPIndex].messages);
// CWDebugLog("~~~~~~ End of Stop Retransmission");
}
}
CW_THREAD_RETURN_TYPE CWWTPReceiveFreqStats(void *arg)
{
int recSock, rlen, k, fragmentsNum = 0;
struct sockaddr_in servaddr, client_addr;
socklen_t slen = sizeof(client_addr);
char buffer[PACKET_SIZE];
CWProtocolMessage *completeMsgPtr = NULL;
CWProtocolMessage *data = NULL;
CWBindingTransportHeaderValues *bindingValuesPtr = NULL;
CWThreadSetSignals(SIG_BLOCK, 1, SIGALRM);
/* Create an Inet UDP socket for this thread (Receive freq/ack packets) */
if ( ( recSock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) ) < 0 ) {
CWDebugLog("Thread Frequency Receive Stats: Error creating socket");
CWExitThread();
}
/* Set up address structure for server socket */
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
servaddr.sin_port = htons(SERVER_PORT);
/* Binding Socket */
if ( bind(recSock, (struct sockaddr *) &servaddr, sizeof(struct sockaddr_in)) < 0 ) {
CWDebugLog("Thread Frequency Receive Stats: Binding Socket Error");
close(recSock);
CWExitThread();
}
CW_REPEAT_FOREVER /* Receive data Loop */
{
memset(buffer, 0, PACKET_SIZE);
fragmentsNum = 0;
k = 0;
rlen = 0;
if ( ( rlen = recvfrom(recSock, buffer, PACKET_SIZE, 0, (struct sockaddr *) &client_addr, &slen) ) > 0 )
{
/* Creation of stats/ack message for AC */
CW_CREATE_OBJECT_ERR(data, CWProtocolMessage, return 0;);
CW_CREATE_PROTOCOL_MESSAGE(*data, rlen, return 0;);
CW_THREAD_RETURN_TYPE CWWTPThread_read_data_from_hostapd(void *arg)
{
/*
CWThreadMutexLock(&gRADIO_MAC_mutex);
gRADIO_MAC[0]=0xAA;
gRADIO_MAC[1]=0xBB;
gRADIO_MAC[2]=0xCC;
gRADIO_MAC[3]=0xDD;
gRADIO_MAC[4]=0xEE;
gRADIO_MAC[5]=0xFF;
CWThreadMutexUnlock(&gRADIO_MAC_mutex);
*/
int len;
#if defined(LOCALUDP)
struct sockaddr_un server;
#else
#if defined(USEIPV6)
struct sockaddr_in6 server;
#else
struct sockaddr_in server;
#endif
#endif
unsigned char buffer[CW_BUFFER_SIZE];
int connect_ret;
unsigned char cmd[10];
CWProtocolMessage *frame = NULL;
CWBindingDataListElement *listElement = NULL;
CWThreadSetSignals(SIG_BLOCK, 1, SIGALRM);
#if defined(LOCALUDP)
sock = socket(AF_UNIX, SOCK_DGRAM, 0);
#elif defined(NETUDP)
#if defined(USEIPV6)
bzero(&server, sizeof(server));
sock = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
#else
memset(&server, 0, sizeof(server));
sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#endif
#else
#if defined(USEIPV6)
bzero(&server, sizeof(server));
sock = socket(AF_INET6, SOCK_SEQPACKET, IPPROTO_SCTP);
#else
memset(&server, 0, sizeof(server));
sock = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
#endif
#endif
if (sock < 0) {
CWDebugLog("WTP ipc HOSTAPD: Error creating socket");
EXIT_FRAME_THREAD(sock);
}
CWDebugLog("WTP ipc HOSTAPD: Trying to connect to hostapd (wtp)...");
#if defined(LOCALUDP)
server.sun_family = AF_UNIX;
strcpy(server.sun_path, gHostapd_unix_path);
unlink(server.sun_path);
connect_ret = bind(sock, (struct sockaddr *)&server, strlen(server.sun_path) + sizeof(server.sun_family));
client.sun_family = AF_UNIX;
#else
#if defined(USEIPV6)
server.sin6_family = AF_INET6;
server.sin6_port = gHostapd_port;
server.sin6_addr = in6addr_any;
#else
server.sin_family = AF_INET;
server.sin_port = gHostapd_port;
server.sin_addr.s_addr = INADDR_ANY;
#endif
connect_ret = bind(sock, (struct sockaddr *)&server, sizeof(server));
#endif
if (connect_ret == -1) {
CWDebugLog("WTP ipc HOSTAPD: Error connect/bind to socket");
EXIT_FRAME_THREAD(sock);
}
#if defined(LOCALUDP)
#elif defined(NETUDP)
#else
/* 1: Only one daemon Hostapd_WTP at time */
if (listen(sock, 1) < 0) {
CWDebugLog("WTP ipc HOSTAPD: Error listen ");
EXIT_FRAME_THREAD(sock);
}
#endif
#if defined(LOCALUDP)
CWDebugLog("Waiting packet from Hostapd_WTP at Pipe:%s", gHostapd_unix_path);
#else
CWDebugLog("Waiting packet from Hostapd_WTP at Port:%d", gHostapd_port);
#endif
client.sin_family = AF_INET;
client.sin_addr.s_addr = inet_addr("127.0.0.1");
client.sin_port = htons(6444);
address_size = sizeof(client);
int sig_byte = 1;
#if defined(LOCALUDP)
sig_byte += 5;
#endif
CWDebugLog("Checking if hostapd is started already");
cmd[0] = CONNECT_R;
sendto(sock, cmd, 1, 0, (struct sockaddr *)&client, address_size);
cmd[0] = WTPRINFO; //Next info to get
sendto(sock, cmd, 1, 0, (struct sockaddr *)&client, address_size);
CW_REPEAT_FOREVER {
len = recvfrom(sock, buffer, sizeof(buffer), 0, (struct sockaddr *)&client, &address_size);
#if defined(LOCALUDP)
sprintf(client.sun_path, "%s%c%c%c%c%c", server.sun_path, buffer[1], buffer[2], buffer[3], buffer[4],
buffer[5]);
#endif
if (len <= 0) {
EXIT_FRAME_THREAD(sock)
}
if (connected == 0 && buffer[0] != CONNECT && buffer[0] != WTPRINFO_R) {
CWDebugLog("IPC packet - WTP is not in RUN state");
CWWTPsend_command_to_hostapd_CLOSE(cmd, 10);
continue;
}
if (buffer[0] == DATE_TO_AC) {
if (!wtpInRunState)
continue;
if (!extract802_11_Frame(&frame, buffer + sig_byte, len - sig_byte)) {
CWLog("THR FRAME: Error extracting a frame");
EXIT_FRAME_THREAD(sock);
}
CWDebugLog("Send 802.11 management(len:%d) to AC", len - 1);
CW_CREATE_OBJECT_ERR(listElement, CWBindingDataListElement, EXIT_FRAME_THREAD(sock);
);
listElement->frame = frame;
listElement->bindingValues = NULL;
listElement->frame->data_msgType = CW_IEEE_802_11_FRAME_TYPE;
CWLockSafeList(gFrameList);
CWAddElementToSafeListTail(gFrameList, listElement, sizeof(CWBindingDataListElement));
CWUnlockSafeList(gFrameList);
} else if (buffer[0] == CONNECT) {
int main (int argc, const char * argv[]) {
/* Daemon Mode */
pid_t pid;
if (argc <= 1)
printf("Usage: WTP working_path\n");
if ((pid = fork()) < 0)
exit(1);
else if (pid != 0)
exit(0);
else {
setsid();
if (chdir(argv[1]) != 0){
printf("chdir Faile\n");
exit(1);
}
fclose(stdout);
}
CWStateTransition nextState = CW_ENTER_DISCOVERY;
CWLogInitFile(WTP_LOG_FILE_NAME);
#ifndef CW_SINGLE_THREAD
CWDebugLog("Use Threads");
#else
CWDebugLog("Don't Use Threads");
#endif
CWErrorHandlingInitLib();
if(!CWParseSettingsFile()){
CWLog("Can't start WTP");
exit(1);
}
/* Capwap receive packets list */
if (!CWErr(CWCreateSafeList(&gPacketReceiveList)))
{
CWLog("Can't start WTP");
exit(1);
}
/* Capwap receive frame list */
if (!CWErr(CWCreateSafeList(&gFrameList)))
{
CWLog("Can't start WTP");
exit(1);
}
CWCreateThreadMutex(&gInterfaceMutex);
CWSetMutexSafeList(gPacketReceiveList, &gInterfaceMutex);
CWSetMutexSafeList(gFrameList, &gInterfaceMutex);
CWCreateThreadCondition(&gInterfaceWait);
CWSetConditionSafeList(gPacketReceiveList, &gInterfaceWait);
CWSetConditionSafeList(gFrameList, &gInterfaceWait);
CWLog("Starting WTP...");
CWRandomInitLib();
CWThreadSetSignals(SIG_BLOCK, 1, SIGALRM);
if (timer_init() == 0) {
CWLog("Can't init timer module");
exit(1);
}
#ifdef CW_NO_DTLS
if( !CWErr(CWWTPLoadConfiguration()) ) {
#else
if( !CWErr(CWSecurityInitLib()) || !CWErr(CWWTPLoadConfiguration()) ) {
#endif
CWLog("Can't start WTP");
exit(1);
}
CWDebugLog("Init WTP Radio Info");
if(!CWWTPInitConfiguration())
{
CWLog("Error Init Configuration");
exit(1);
}
#ifdef SOFTMAC
CWThread thread_ipc_with_wtp_hostapd;
if(!CWErr(CWCreateThread(&thread_ipc_with_wtp_hostapd, CWWTPThread_read_data_from_hostapd, NULL))) {
CWLog("Error starting Thread that receive command and 802.11 frame from hostapd (WTP side)");
exit(1);
}
#endif
CWThread thread_receiveFrame;
if(!CWErr(CWCreateThread(&thread_receiveFrame, CWWTPReceiveFrame, NULL))) {
CWLog("Error starting Thread that receive binding frame");
exit(1);
}
CWThread thread_receiveStats;
if(!CWErr(CWCreateThread(&thread_receiveStats, CWWTPReceiveStats, NULL))) {
CWLog("Error starting Thread that receive stats on monitoring interface");
exit(1);
}
/****************************************
* 2009 Update: *
* Spawn Frequency Stats *
* Receiver Thread *
****************************************/
CWThread thread_receiveFreqStats;
if(!CWErr(CWCreateThread(&thread_receiveFreqStats, CWWTPReceiveFreqStats, NULL))) {
CWLog("Error starting Thread that receive frequency stats on monitoring interface");
exit(1);
}
/* if AC address is given jump Discovery and use this address for Joining */
if(gWTPForceACAddress != NULL) nextState = CW_ENTER_JOIN;
/* start CAPWAP state machine */
CW_REPEAT_FOREVER {
switch(nextState) {
case CW_ENTER_DISCOVERY:
nextState = CWWTPEnterDiscovery();
break;
case CW_ENTER_SULKING:
nextState = CWWTPEnterSulking();
break;
case CW_ENTER_JOIN:
nextState = CWWTPEnterJoin();
break;
case CW_ENTER_CONFIGURE:
nextState = CWWTPEnterConfigure();
break;
case CW_ENTER_DATA_CHECK:
nextState = CWWTPEnterDataCheck();
break;
case CW_ENTER_RUN:
nextState = CWWTPEnterRun();
break;
case CW_ENTER_RESET:
/*
* CWStopHeartbeatTimer();
* CWStopNeighborDeadTimer();
* CWNetworkCloseSocket(gWTPSocket);
* CWSecurityDestroySession(gWTPSession);
* CWSecurityDestroyContext(gWTPSecurityContext);
* gWTPSecurityContext = NULL;
* gWTPSession = NULL;
*/
nextState = CW_ENTER_DISCOVERY;
break;
case CW_QUIT:
CWWTPDestroy();
return 0;
}
}
}
__inline__ unsigned int CWGetSeqNum() {
static unsigned int seqNum = 0;
if (seqNum==CW_MAX_SEQ_NUM) seqNum=0;
else seqNum++;
return seqNum;
}
__inline__ int CWGetFragmentID() {
static int fragID = 0;
return fragID++;
}
/*
* Parses config file and inits WTP configuration.
*/
CWBool CWWTPLoadConfiguration() {
int i;
CWLog("WTP Loads Configuration");
/* get saved preferences */
if(!CWErr(CWParseConfigFile())) {
CWLog("Can't Read Config File");
exit(1);
}
if(gCWACCount == 0)
return CWErrorRaise(CW_ERROR_NEED_RESOURCE, "No AC Configured");
CW_CREATE_ARRAY_ERR(gCWACList,
gCWACCount,
CWACDescriptor,
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL););
for(i = 0; i < gCWACCount; i++) {
CWDebugLog("Init Configuration for AC at %s", gCWACAddresses[i]);
CW_CREATE_STRING_FROM_STRING_ERR(gCWACList[i].address, gCWACAddresses[i],
return CWErrorRaise(CW_ERROR_OUT_OF_MEMORY, NULL););
}
CW_THREAD_RETURN_TYPE CWACipc_with_ac_hostapd(void *arg){
int tmp_WTPIndex = -1;
int len;
int k;
#if defined(LOCALUDP)
struct sockaddr_un server;
#else
#if defined(USEIPV6)
struct sockaddr_in6 server;
#else
struct sockaddr_in server;
#endif
#endif
unsigned char buffer[2048];
int connect_ret;
char cmd[10];
CWProtocolMessage* frame=NULL;
CWNetworkLev4Address address;
CWThreadSetSignals(SIG_BLOCK, 1, SIGALRM);
#if defined(LOCALUDP)
sock = socket(AF_UNIX, SOCK_DGRAM, 0);
#elif defined(NETUDP)
#if defined(USEIPV6)
bzero(&server, sizeof(server));
sock = socket(AF_INET6,SOCK_DGRAM,IPPROTO_UDP);
#else
memset(&server, 0, sizeof(server));
sock = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);
#endif
#else
#if defined(USEIPV6)
bzero(&server, sizeof(server));
sock = socket(AF_INET6,SOCK_SEQPACKET,IPPROTO_SCTP);
#else
memset(&server, 0, sizeof(server));
sock = socket(AF_INET,SOCK_SEQPACKET,IPPROTO_SCTP);
#endif
#endif
if (sock < 0) {
CWDebugLog("AC ipc HOSTAPD: Error creating socket");
EXIT_FRAME_THREAD(sock);
}
CWDebugLog("AC ipc HOSTAPD: Trying to connect to hostapd (AC)...");
#if defined(LOCALUDP)
server.sun_family = AF_UNIX;
strcpy(server.sun_path, gHostapd_unix_path);
unlink(server.sun_path);
connect_ret = bind(sock, (struct sockaddr *)&server, strlen(server.sun_path) + sizeof(server.sun_family));
#else
#if defined(USEIPV6)
server.sin6_family = AF_INET6;
server.sin6_port = gHostapd_port;
server.sin6_addr = in6addr_any;
#else
server.sin_family = AF_INET;
server.sin_port = gHostapd_port;
server.sin_addr.s_addr = INADDR_ANY;
#endif
connect_ret = bind(sock,(struct sockaddr *)&server,sizeof(server));
#endif
if ( connect_ret == -1) {
CWDebugLog("AC ipc HOSTAPD: Error connect to socket");
EXIT_FRAME_THREAD(sock);
}
#if defined(LOCALUDP)
#elif defined(NETUDP)
#else
if (listen(sock, CW_MAX_WTP) < 0){
CWDebugLog("AC ipc HOSTAPD: Error listen ");
EXIT_FRAME_THREAD(sock);
}
#endif
int i=0;
CWProtocolMessage *completeMsgPtr = NULL;
int fragmentsNum = 0;
CWMultiHomedSocket *sockPtr = &gACSocket;
int dataSocket=0;
#if defined(LOCALUDP)
struct sockaddr_un client_tmp;
client_tmp.sun_family = AF_UNIX;
#else
#if defined(USEIPV6)
struct sockaddr_in6 client_tmp;
#else
struct sockaddr_in client_tmp;
#endif
#endif
int address_size_tmp = sizeof(client_tmp);
for(i=0; i<CW_MAX_WTP; i++){
ch[i].associated = 0;
#if defined(LOCALUDP)
ch[i].client.sun_family = AF_UNIX;
ch[i].address_size = sizeof(struct sockaddr_un);
#else
#if defined(USEIPV6)
ch[i].client.sin6_port = 0;
#else
ch[i].client.sin_port = 0;
#endif
#endif
}
#if defined(LOCALUDP)
CWLog("Accept Packet at pipe: %s",gHostapd_unix_path);
#elif defined(NETUDP)
#if defined(USEIPV6)
CWLog("Accept UDP v6 Packet at Port: %d",server.sin6_port);
#else
CWLog("Accept UDP v4 Packet at Port: %d",server.sin_port);
#endif
#else
#if defined(USEIPV6)
CWLog("Accept SCTP v6 Packet at Port: %d",server.sin6_port);
#else
CWLog("Accept SCTP v4 Packet at Port: %d",server.sin_port);
#endif
#endif
CW_REPEAT_FOREVER {
tmp_WTPIndex = -1;
len = recvfrom(sock, buffer, 3000, 0, (struct sockaddr *)&client_tmp, &address_size_tmp);
#if defined(LOCALUDP)
sprintf(client_tmp.sun_path, "%s%c%c%c%c%c",server.sun_path, buffer[1],buffer[2],buffer[3],buffer[4],buffer[5]);
#endif
if(Exist_WTPs()==0){
send_close_cmd(client_tmp,sizeof(client_tmp));
continue;
}
if(len <= 0 ) { continue; /* EXIT_FRAME_THREAD(sock) */ }
for( i=0; i<CW_MAX_WTP; i++){
#if defined(LOCALUDP)
if( strcmp(client_tmp.sun_path,ch[i].client.sun_path)==0 ){
tmp_WTPIndex = i;
break;
}
#else
#if defined(USEIPV6)
if( (client_tmp.sin6_port == ch[i].client.sin6_port) &&
(strncmp(client_tmp.sin6_addr.s6_addr,ch[i].client.sin6_addr.s6_addr,16)==0 )){
tmp_WTPIndex = i;
}
#else
if( (client_tmp.sin_port == ch[i].client.sin_port) &&
(strcmp(inet_ntoa(client_tmp.sin_addr),inet_ntoa(ch[i].client.sin_addr))==0 )){
tmp_WTPIndex = i;
}
#endif
#endif
}
if( tmp_WTPIndex<0 ){// Client not recognized
int wtp_non_associated = GetWTP_not_associated_to_Hostapd ();
if( wtp_non_associated >= 0){
if( buffer[0]==CONNECT ){
ch[wtp_non_associated].live = 0;
ch[wtp_non_associated].start_set_fase = 0;
ch[wtp_non_associated].associated = 1;
ch[wtp_non_associated].client = client_tmp;
ch[wtp_non_associated].address_size = address_size_tmp;
cmd[0] = CONNECT_R;
sendto(sock, cmd, 1, 0, (struct sockaddr *)&ch[wtp_non_associated].client, ch[wtp_non_associated].address_size);
CWLog("wtp_non_associated:%d",wtp_non_associated);
#if defined(LOCALUDP)
CWLog("Hostapd_AC Connect: %s", ch[wtp_non_associated].client.sun_path);
#else
#if defined(USEIPV6)
CWLog("Hostapd_AC (v6) Connect: %d", ch[wtp_non_associated].client.sin6_port);
#else
CWLog("Hostapd_AC (v4) Connect: %s:%d",inet_ntoa(ch[wtp_non_associated].client.sin_addr), ch[wtp_non_associated].client.sin_port);
#endif
#endif
continue;
}else{
send_close_cmd(client_tmp,sizeof(client_tmp));
continue;
}
}else{
send_close_cmd(client_tmp,sizeof(client_tmp));
continue;
}
}else{ // Client recognized
int sig_byte = 1;
#if defined(LOCALUDP)
sig_byte = 6; //Code
#endif
if( buffer[0]==DATE_TO_WTP ){
if (gWTPs[tmp_WTPIndex].currentState != CW_ENTER_RUN){
CWDebugLog("AC %d is not in RUN State. The packet was dropped.",i);
continue;
}else if (len > (gWTPs[tmp_WTPIndex].pathMTU-20)){
CWDebugLog("802.11 data length(%d) > MTU(%d)",len, gWTPs[tmp_WTPIndex].pathMTU);
continue;
}else{
len = len - sig_byte;
CW_CREATE_OBJECT_ERR(frame, CWProtocolMessage, return 0;);
CW_CREATE_PROTOCOL_MESSAGE(*frame, len, return 0;);
memcpy(frame->msg, buffer + sig_byte , len);
frame->offset=len;
frame->data_msgType = CW_IEEE_802_11_FRAME_TYPE;
if (!CWAssembleDataMessage(&completeMsgPtr, &fragmentsNum, gWTPs[tmp_WTPIndex].pathMTU, frame, NULL, CW_PACKET_PLAIN, 0)){
for(k = 0; k < fragmentsNum; k++){
CW_FREE_PROTOCOL_MESSAGE(completeMsgPtr[k]);
}
CW_FREE_OBJECT(completeMsgPtr);
CW_FREE_PROTOCOL_MESSAGE(*frame);
CW_FREE_OBJECT(frame);
continue;
}
for(k = 0; k < sockPtr->count; k++) {
if (sockPtr->interfaces[k].sock == gWTPs[tmp_WTPIndex].socket){
dataSocket = sockPtr->interfaces[k].dataSock;
CW_COPY_NET_ADDR_PTR(&address,&(gWTPs[tmp_WTPIndex].dataaddress));
break;
}
}
if (dataSocket == 0){
CWDebugLog("data socket of WTP %d isn't ready.");
continue;
}
for (k = 0; k < fragmentsNum; k++){
if(!CWNetworkSendUnsafeUnconnected( dataSocket, &(address),completeMsgPtr[k].msg,completeMsgPtr[k].offset)){
CWDebugLog("Failure sending Request");
break;
}
}
for (k = 0; k < fragmentsNum; k++){
CW_FREE_PROTOCOL_MESSAGE(completeMsgPtr[k]);
}
CW_FREE_OBJECT(completeMsgPtr);
CW_FREE_PROTOCOL_MESSAGE(*(frame));
CW_FREE_OBJECT(frame);
}
}else if( buffer[0]==SET_ADDR ){
void CWACInit() {
int i;
CWNetworkLev4Address *addresses = NULL;
struct sockaddr_in *IPv4Addresses = NULL;
CWLogInitFile(AC_LOG_FILE_NAME);
#ifndef CW_SINGLE_THREAD
CWDebugLog("Use Threads");
#else
CWDebugLog("Don't Use Threads");
#endif
CWErrorHandlingInitLib();
if(!CWParseSettingsFile())
{
CWLog("Can't start AC");
exit(1);
}
CWLog("Starting AC");
CWThreadSetSignals(SIG_BLOCK, 1, SIGALRM);
if (timer_init() == 0) {
CWLog("Can't init timer module");
exit(1);
}
if(!CWErr(CWParseConfigFile()) ||
#ifndef CW_NO_DTLS
!CWErr(CWSecurityInitLib()) ||
#endif
!CWErr(CWNetworkInitSocketServerMultiHomed(&gACSocket, CW_CONTROL_PORT, gMulticastGroups, gMulticastGroupsCount)) ||
!CWErr(CWNetworkGetInterfaceAddresses(&gACSocket, &addresses, &IPv4Addresses)) ||
!CWErr(CWCreateThreadMutex(&gWTPsMutex)) ||
!CWErr(CWCreateThreadMutex(&gActiveWTPsMutex))) {
/* error starting */
CWLog("Can't start AC");
exit(1);
}
#ifndef CW_NO_DTLS
if(gACDescriptorSecurity == CW_X509_CERTIFICATE) {
if(!CWErr(CWSecurityInitContext(&gACSecurityContext,
"root.pem",
"server.pem",
"prova",
CW_FALSE,
CWACSemPostForOpenSSLHack))) {
CWLog("Can't start AC");
exit(1);
}
} else { /* preshared */
if(!CWErr(CWSecurityInitContext(&gACSecurityContext,
NULL,
NULL,
NULL,
CW_FALSE,
CWACSemPostForOpenSSLHack))) {
CWLog("Can't start AC");
exit(1);
}
}
#endif
CW_FREE_OBJECTS_ARRAY(gMulticastGroups, gMulticastGroupsCount);
for(i = 0; i < CW_MAX_WTP; i++) {
gWTPs[i].isNotFree = CW_FALSE;
}
/* store network interface's addresses */
gInterfacesCount = CWNetworkCountInterfaceAddresses(&gACSocket);
CWLog("Found %d Network Interface(s)", gInterfacesCount);
if (gInterfacesCount<=0){
CWLog("Can't start AC");
exit(1);
}
CW_CREATE_ARRAY_ERR(gInterfaces,
gInterfacesCount,
CWProtocolNetworkInterface,
CWLog("Out of Memory"); return;);
