316 lines
6.8 KiB
C
316 lines
6.8 KiB
C
/*
|
|
This file is part of AC-Tube.
|
|
|
|
AC-Tube is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
AC-Tube is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <netdb.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
|
|
|
|
#include "capwap/capwap.h"
|
|
#include "capwap/cw_log.h"
|
|
#include "capwap/wtpinfo.h"
|
|
#include "capwap/acinfo.h"
|
|
#include "capwap/sock.h"
|
|
#include "capwap/cw_util.h"
|
|
|
|
#include "wtp.h"
|
|
#include "wtp_conf.h"
|
|
#include "wtp_interface.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
struct discovery_info{
|
|
ACIPLIST * aciplist;
|
|
struct conn * conn;
|
|
int response_count;
|
|
};
|
|
|
|
static int acprint(void *p,void*d) //,int ctr)
|
|
{
|
|
|
|
|
|
ACIP * ip = (ACIP*)d;
|
|
char str[100];
|
|
sock_addrtostr((struct sockaddr*)&ip->ip,str,100);
|
|
// printf("ACIP: %s\n",str);
|
|
// printf("CTR: %i\n",ip->wtp_count);
|
|
return 1;
|
|
}
|
|
|
|
|
|
|
|
|
|
static int msg_cb(void *priv,struct cwrmsg * cwrmsg)
|
|
{
|
|
if (cwrmsg->type != CWMSG_DISCOVERY_RESPONSE){
|
|
cw_log_debug0("Expected discovery response, but received %i",cwrmsg->type);
|
|
return 1;
|
|
}
|
|
|
|
struct discovery_info * di = (struct discovery_info*)priv;
|
|
|
|
if (di->conn->seqnum != cwrmsg->seqnum){
|
|
cw_log_debug0("Ignoring discovery respone, seqnum=%i, expected seqnum %i",cwrmsg->seqnum,di->conn->seqnum);
|
|
return 1;
|
|
}
|
|
|
|
struct ac_info acinfo;
|
|
memset(&acinfo,0,sizeof(acinfo));
|
|
|
|
acinfo.aciplist = di->aciplist;
|
|
|
|
cwread_discovery_response(&acinfo,cwrmsg->msgelems,cwrmsg->msgelems_len);
|
|
|
|
/*
|
|
printf("AC NAME %s\n",acinfo.ac_name);
|
|
printf("AC Software version %s\n",acinfo.software_version);
|
|
printf("AC Hardwareversion %s\n",acinfo.hardware_version);
|
|
|
|
printf("Active wtps: %i\n",acinfo.active_wtps);
|
|
printf("Active max wtps: %i\n",acinfo.max_wtps);
|
|
|
|
|
|
printf("Got Discovery response\n");
|
|
|
|
printf("ACL COUNT: %i\n",acinfo.aciplist->count);
|
|
*/
|
|
aciplist_foreach(acinfo.aciplist,acprint,0);
|
|
|
|
// responses++;
|
|
//
|
|
di->response_count++;
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void rand_sleep(int seconds)
|
|
{
|
|
int usecs = seconds * 1000;
|
|
uint16_t rnd;
|
|
cw_rand((uint8_t*)&rnd,sizeof(rnd));
|
|
uint16_t max = 0-1;
|
|
int r = (rnd * usecs) / max;
|
|
cw_log_debug0("Sleeping for %u milliseconds\n",r);
|
|
usleep(r*1000);
|
|
}
|
|
|
|
|
|
static int do_discover_conn(struct conn * conn,struct discovery_info * di)
|
|
{
|
|
rand_sleep(conf_max_discovery_interval);
|
|
|
|
|
|
struct wtpinfo * wtpinfo;
|
|
wtpinfo = get_wtpinfo();
|
|
// wtpinfo_print(wtpinfo);
|
|
|
|
|
|
// struct timespec tstart,tcur;
|
|
struct radioinfo ri;
|
|
memset(&ri,0,sizeof(ri));
|
|
|
|
|
|
#ifdef WITH_CW_LOG_DEBUG
|
|
char str[100];
|
|
sock_addrtostr((struct sockaddr*)&conn->addr,str,100);
|
|
cw_log_debug0("Sending discovery request to %s",str);
|
|
#endif
|
|
|
|
int rc;
|
|
|
|
do {
|
|
rc = cwsend_discovery_request(conn,&ri,wtpinfo);
|
|
if (rc<0){
|
|
if (errno == EINTR)
|
|
continue;
|
|
if (errno == EMSGSIZE){
|
|
conn->mtu-=4;
|
|
cw_log_debug2("Setting mtu to %i",conn->mtu);
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}while (rc<0);
|
|
|
|
|
|
if (rc < 0 )
|
|
{
|
|
char str[100];
|
|
sock_addrtostr((struct sockaddr*)&conn->addr,str,100);
|
|
cw_log(LOG_ERR,"Error sending discovery request to %s: %s",str,strerror(errno));
|
|
return 0;
|
|
}
|
|
|
|
struct connlist * connlist;
|
|
connlist = connlist_create(30);
|
|
|
|
// clock_gettime(CLOCK_REALTIME,&tstart);
|
|
//
|
|
int tstart = time(0);
|
|
int treset = 0;
|
|
do {
|
|
char buf[2048];
|
|
int buflen=2048;
|
|
struct sockaddr_storage sa;
|
|
socklen_t fromlen=sizeof(struct sockaddr_storage);
|
|
rc = recvfrom(conn->sock,buf,buflen,0,(struct sockaddr*)&sa,&fromlen);
|
|
if (rc<0){
|
|
if (errno==EINTR)
|
|
rc=0;
|
|
if (errno==EAGAIN)
|
|
rc=0;
|
|
if (errno==EWOULDBLOCK)
|
|
rc=0;
|
|
}
|
|
if (rc>0) {
|
|
#ifdef WITH_CW_LOG_DEBUG
|
|
char str[100];
|
|
sock_addrtostr((struct sockaddr*)&sa,str,100);
|
|
cw_log_debug0("Received packet from %s",str);
|
|
#endif
|
|
|
|
struct conn * rconn;
|
|
rconn = connlist_get(connlist,(struct sockaddr*)&sa);
|
|
|
|
if (!rconn){
|
|
rconn = conn_create(conn->sock,(struct sockaddr*)&sa,0); //msg_cb,NULL,0);
|
|
// rconn->pmsgarg=conn->pmsgarg;
|
|
rconn->mtu = conn->mtu;
|
|
rconn->seqnum=conn->seqnum;
|
|
connlist_add(connlist,rconn);
|
|
}
|
|
|
|
conn_process_packet(rconn,(uint8_t*)buf,rc,msg_cb,di);
|
|
}
|
|
|
|
/* reset discovery timer after we have received the first response */
|
|
if ( di->response_count == 1 && !treset ){
|
|
tstart=time(0);
|
|
treset=1;
|
|
}
|
|
|
|
//clock_gettime(CLOCK_REALTIME,&tcur);
|
|
// printf("TTSub: %i %i\n",time(0)-tstart, conf_discovery_interval);
|
|
}while(time(0)-tstart < conf_discovery_interval && rc>=0 );
|
|
|
|
|
|
if (rc <0){
|
|
char str[100];
|
|
sock_addrtostr((struct sockaddr*)&conn->addr,str,100);
|
|
cw_log(LOG_ERR,"Error sendings discovery request to %s: %s",str,strerror(errno));
|
|
}
|
|
|
|
connlist_destroy(connlist);
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int discovery_count;
|
|
|
|
ACIPLIST * do_discovery(const char *acaddr)
|
|
{
|
|
|
|
/* get an partially intialized connection object
|
|
* (seqnum should be set)
|
|
* */
|
|
struct conn * conn = get_conn();
|
|
if (!conn){
|
|
cw_log(LOG_ERR,"Can't create conn for %s: %s",acaddr,strerror(errno));
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* get addr of destination */
|
|
struct addrinfo hints;
|
|
struct addrinfo * res,*res0;
|
|
memset(&hints,0,sizeof(hints));
|
|
|
|
hints.ai_socktype = SOCK_DGRAM;
|
|
hints.ai_family = PF_UNSPEC;
|
|
|
|
int rc = getaddrinfo(acaddr,conf_control_port,&hints,&res0);
|
|
if(rc){
|
|
cw_log(LOG_ERR,"Can't connect to AC %s: %s",acaddr,gai_strerror(rc));
|
|
return 0;
|
|
}
|
|
|
|
struct discovery_info di;
|
|
memset (&di,0,sizeof(struct discovery_info));
|
|
di.aciplist = aciplist_create();
|
|
di.response_count=0;
|
|
|
|
|
|
for(res=res0; res; res=res->ai_next)
|
|
{
|
|
if ( discovery_count >= conf_max_discoveries){
|
|
sulking_state();
|
|
discovery_count=0;
|
|
cw_log_debug0("Entering discovery state");
|
|
}
|
|
discovery_count++;
|
|
|
|
|
|
/* create socket */
|
|
int sockfd;
|
|
int opt;
|
|
sockfd=socket(res->ai_family,SOCK_DGRAM,0);
|
|
if (sockfd == -1){
|
|
cw_log(LOG_ERR,"Can't create socket for %s: %s",acaddr,strerror(errno));
|
|
continue;
|
|
}
|
|
|
|
opt = 1;
|
|
if (setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &opt, sizeof(opt))<0){
|
|
cw_log(LOG_ERR,"Cant set broadcast sockopt");
|
|
}
|
|
sock_set_recvtimeout(sockfd,1);
|
|
|
|
sock_set_dontfrag(sockfd,0);
|
|
|
|
di.conn=conn;
|
|
|
|
sock_copyaddr(&conn->addr,res->ai_addr);
|
|
conn->sock=sockfd;
|
|
|
|
do_discover_conn(conn,&di);
|
|
|
|
close(sockfd);
|
|
|
|
if ( di.aciplist->count != 0)
|
|
break;
|
|
|
|
}
|
|
|
|
freeaddrinfo(res0);
|
|
|
|
if (di.aciplist->count){
|
|
cw_log_debug2("Discover responses received: %i\n",di.response_count);
|
|
return di.aciplist;
|
|
|
|
}
|
|
|
|
aciplist_destroy(di.aciplist);
|
|
return 0;
|
|
}
|
|
|
|
|