static void Handle_reload_config(
rtapd *rtapd)
{
struct rtapd_config *newconf;
#if MULTIPLE_RADIUS
int i;
#endif // MULTIPLE_RADIUS //
DBGPRINT(RT_DEBUG_TRACE, "Reloading configuration\n");
/* create new config */
newconf = Config_read(rtapd->ioctl_sock, rtapd->prefix_wlan_name);
if (newconf == NULL)
{
DBGPRINT(RT_DEBUG_ERROR, "Failed to read new configuration file - continuing with old.\n");
return;
}
/* TODO: update dynamic data based on changed configuration
* items (e.g., open/close sockets, remove stations added to
* deny list, etc.) */
Radius_client_flush(rtapd);
Config_free(rtapd->conf);
rtapd->conf = newconf;
Apd_free_stas(rtapd);
/* when reStartAP, no need to reallocate sock
for (i = 0; i < rtapd->conf->SsidNum; i++)
{
if (rtapd->sock[i] >= 0)
close(rtapd->sock[i]);
rtapd->sock[i] = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (rtapd->sock[i] < 0)
{
perror("socket[PF_PACKET,SOCK_RAW]");
return;
}
}*/
#if MULTIPLE_RADIUS
for (i = 0; i < MAX_MBSSID_NUM; i++)
rtapd->radius->mbss_auth_serv_sock[i] = -1;
#else
rtapd->radius->auth_serv_sock = -1;
#endif
if (Radius_client_init(rtapd))
{
DBGPRINT(RT_DEBUG_ERROR,"RADIUS client initialization failed.\n");
return;
}
#if MULTIPLE_RADIUS
for (i = 0; i < rtapd->conf->SsidNum; i++)
DBGPRINT(RT_DEBUG_TRACE, "auth_serv_sock[%d] = %d\n", i, rtapd->radius->mbss_auth_serv_sock[i]);
#else
DBGPRINT(RT_DEBUG_TRACE,"rtapd->radius->auth_serv_sock = %d\n",rtapd->radius->auth_serv_sock);
#endif
}
static rtapd * Apd_init(const char *prefix_name)
{
rtapd *rtapd;
int i;
rtapd = malloc(sizeof(*rtapd));
if (rtapd == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"Could not allocate memory for rtapd data\n");
goto fail;
}
memset(rtapd, 0, sizeof(*rtapd));
rtapd->prefix_wlan_name = strdup(prefix_name);
if (rtapd->prefix_wlan_name == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"Could not allocate memory for prefix_wlan_name\n");
goto fail;
}
// init ioctl socket
rtapd->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
if (rtapd->ioctl_sock < 0)
{
DBGPRINT(RT_DEBUG_ERROR,"Could not init ioctl socket \n");
goto fail;
}
rtapd->conf = Config_read(rtapd->ioctl_sock, rtapd->prefix_wlan_name);
if (rtapd->conf == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"Could not allocate memory for rtapd->conf \n");
goto fail;
}
for (i = 0; i < MAX_MBSSID_NUM; i++)
{
rtapd->wlan_sock[i] = -1;
rtapd->eth_sock[i] = -1;
}
return rtapd;
fail:
if (rtapd)
{
if (rtapd->conf)
Config_free(rtapd->conf);
if (rtapd->prefix_wlan_name)
free(rtapd->prefix_wlan_name);
free(rtapd);
}
return NULL;
}
static void Handle_usr1(int sig, void *eloop_ctx, void *signal_ctx)
{
struct hapd_interfaces *rtapds = (struct hapd_interfaces *) eloop_ctx;
struct rtapd_config *newconf;
int i;
DBGPRINT(RT_DEBUG_TRACE,"Reloading configuration\n");
for (i = 0; i < rtapds->count; i++)
{
rtapd *rtapd = rtapds->rtapd[i];
newconf = Config_read(rtapd->config_fname,0);
if (newconf == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"Failed to read new configuration file - continuing with old.\n");
continue;
}
/* TODO: update dynamic data based on changed configuration
* items (e.g., open/close sockets, remove stations added to
* deny list, etc.) */
Radius_client_flush(rtapd);
Config_free(rtapd->conf);
rtapd->conf = newconf;
Apd_free_stas(rtapd);
/* when reStartAP, no need to reallocate sock
for (i = 0; i < rtapd->conf->SsidNum; i++)
{
if (rtapd->sock[i] >= 0)
close(rtapd->sock[i]);
rtapd->sock[i] = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (rtapd->sock[i] < 0)
{
perror("socket[PF_PACKET,SOCK_RAW]");
return;
}
}*/
if (Radius_client_init(rtapd))
{
DBGPRINT(RT_DEBUG_ERROR,"RADIUS client initialization failed.\n");
return;
}
#if MULTIPLE_RADIUS
for (i = 0; i < rtapd->conf->SsidNum; i++)
DBGPRINT(RT_DEBUG_TRACE, "auth_serv_sock[%d] = %d\n", i, rtapd->radius->mbss_auth_serv_sock[i]);
#else
DBGPRINT(RT_DEBUG_TRACE,"rtapd->radius->auth_serv_sock = %d\n",rtapd->radius->auth_serv_sock);
#endif
}
}
static void Handle_usr1(int sig, void *eloop_ctx, void *signal_ctx)
{
struct hapd_interfaces *rtapds = (struct hapd_interfaces *) eloop_ctx;
struct rtapd_config *newconf;
int i;
DBGPRINT(RT_DEBUG_TRACE,"Reloading configuration\n");
for (i = 0; i < rtapds->count; i++)
{
rtapd *rtapd = rtapds->rtapd[i];
newconf = Config_read(rtapd->ioctl_sock, rtapd->prefix_wlan_name);
if (newconf == NULL)
{
DBGPRINT(RT_DEBUG_ERROR,"Failed to read new configuration file - continuing with old.\n");
continue;
}
/* TODO: update dynamic data based on changed configuration
* items (e.g., open/close sockets, remove stations added to
* deny list, etc.) */
Radius_client_flush(rtapd);
Config_free(rtapd->conf);
rtapd->conf = newconf;
Apd_free_stas(rtapd);
#if MULTIPLE_RADIUS
for (i = 0; i < MAX_MBSSID_NUM; i++)
rtapd->radius->mbss_auth_serv_sock[i] = -1;
#else
rtapd->radius->auth_serv_sock = -1;
#endif
if (Radius_client_init(rtapd))
{
DBGPRINT(RT_DEBUG_ERROR,"RADIUS client initialization failed.\n");
return;
}
#if MULTIPLE_RADIUS
for (i = 0; i < rtapd->conf->SsidNum; i++)
DBGPRINT(RT_DEBUG_TRACE, "auth_serv_sock[%d] = %d\n", i, rtapd->radius->mbss_auth_serv_sock[i]);
#else
DBGPRINT(RT_DEBUG_TRACE,"rtapd->radius->auth_serv_sock = %d\n",rtapd->radius->auth_serv_sock);
#endif
}
}
static void Apd_cleanup(rtapd *rtapd)
{
int i;
if (rtapd->wlan_sock >= 0)
close(rtapd->wlan_sock);
if (rtapd->ioctl_sock >= 0)
close(rtapd->ioctl_sock);
if (rtapd->eth_sock >= 0)
close(rtapd->eth_sock);
Radius_client_deinit(rtapd);
Config_free(rtapd->conf);
rtapd->conf = NULL;
free(rtapd->config_fname);
}
static void Apd_cleanup(rtapd *rtapd)
{
int i;
for (i = 0; i < rtapd->conf->SsidNum; i++)
{
if (rtapd->sock[i] >= 0)
close(rtapd->sock[i]);
}
if (rtapd->ioctl_sock >= 0)
close(rtapd->ioctl_sock);
Radius_client_deinit(rtapd);
Config_free(rtapd->conf);
rtapd->conf = NULL;
free(rtapd->config_fname);
}
static void Apd_cleanup(rtapd *rtapd)
{
int i;
for (i = 0; i < MAX_MBSSID_NUM; i++)
{
if (rtapd->wlan_sock[i] >= 0)
close(rtapd->wlan_sock[i]);
if (rtapd->eth_sock[i] >= 0)
close(rtapd->eth_sock[i]);
}
if (rtapd->ioctl_sock >= 0)
close(rtapd->ioctl_sock);
Radius_client_deinit(rtapd);
Config_free(rtapd->conf);
rtapd->conf = NULL;
free(rtapd->prefix_wlan_name);
}
struct rtapd_config * Config_read(int ioctl_sock, char *prefix_name)
{
struct rtapd_config *conf;
int errors = 0, i = 0;
int flag = 0;
conf = malloc(sizeof(*conf));
if (conf == NULL)
{
DBGPRINT(RT_DEBUG_TRACE, "Failed to allocate memory for configuration data.\n");
return NULL;
}
memset(conf, 0, sizeof(*conf));
conf->SsidNum = 1;
conf->session_timeout_set = 0xffff;
/* Some related variable per BSS set to default */
for (i = 0; i < MAX_MBSSID_NUM; i++)
{
/* initial default shared-key material and index */
conf->DefaultKeyID[i] = 0; // broadcast key index
conf->individual_wep_key_idx[i] = 3; // unicast key index
conf->individual_wep_key_len[i] = WEP8021X_KEY_LEN; // key length
hostapd_get_rand(conf->IEEE8021X_ikey[i], WEP8021X_KEY_LEN); // generate shared key randomly
/* Initial NAS-ID */
memcpy(conf->nasId[i], "RalinkAP", 8);
conf->nasId[i][8] = '0' + i;
conf->nasId_len[i] = 9;
}
// initial default EAP IF name and Pre-Auth IF name as "br0"
conf->num_eap_if = 1;
conf->num_preauth_if = 1;
strcpy(conf->eap_if_name[0], "br0");
strcpy(conf->preauth_if_name[0], "br0");
// Get parameters from deiver through IOCTL cmd
if(!Query_config_from_driver(ioctl_sock, prefix_name, conf, &errors, &flag))
{
Config_free(conf);
return NULL;
}
#if MULTIPLE_RADIUS
for (i = 0; i < MAX_MBSSID_NUM; i++)
{
struct hostapd_radius_server *servs, *cserv, *nserv;
int c;
conf->mbss_auth_server[i] = conf->mbss_auth_servers[i];
if (!conf->mbss_auth_server[i])
continue;
cserv = conf->mbss_auth_server[i];
servs = conf->mbss_auth_servers[i];
DBGPRINT(RT_DEBUG_TRACE, "%s%d, Current IP: %s \n", prefix_name, i, inet_ntoa(cserv->addr));
for (c = 0; c < conf->mbss_num_auth_servers[i]; c++)
{
nserv = &servs[c];
DBGPRINT(RT_DEBUG_TRACE, " Server IP List: %s \n", inet_ntoa(nserv->addr));
}
}
#else
conf->auth_server = conf->auth_servers;
#endif
if (errors)
{
DBGPRINT(RT_DEBUG_ERROR,"%d errors for radius setting\n", errors);
Config_free(conf);
conf = NULL;
}
if ((flag&0x0f)!=0x0f)
{
DBGPRINT(RT_DEBUG_ERROR,"Not enough necessary parameters are found, flag = %x\n", flag);
Config_free(conf);
conf = NULL;
}
return conf;
}
int main(int argc, char **argv) {
ARGUMENTS *args;
int rv;
FREEPARAM *fp;
AQBACKUP *b;
AQB_INTERACTOR *ia;
CONFIGGROUP *cfg;
CONFIGGROUP *outcfg;
char configfilebuffer[300];
#ifdef HAVE_GETTEXT_ENVIRONMENT
setlocale(LC_ALL,"");
if (bindtextdomain("aqbackup", I18N_PATH)==0) {
fprintf(stderr," Error bindtextdomain()\n");
}
if (textdomain("aqbackup")==0) {
fprintf(stderr," Error textdomain()\n");
}
#endif
args=Arguments_new();
rv=checkArgs(args,argc,argv);
if (rv==-1) {
Arguments_free(args);
return 0;
}
else if (rv) {
Arguments_free(args);
return rv;
}
if (Logger_Open("AQBackup",
args->logFile,
args->logType,
LoggerFacilityUser)) {
fprintf(stderr,I18N("Could not setup logging, aborting.\n"));
return 2;
}
Logger_SetLevel(args->logLevel);
if (args->configFile==0) {
char *p;
p=getHomeDir(configfilebuffer, sizeof(configfilebuffer));
if (!p)
return 2;
p="/.aqbackup";
if (strlen(p)+strlen(configfilebuffer)>=sizeof(configfilebuffer)) {
DBG_ERROR("Buffer too small");
return 2;
}
strcat(configfilebuffer, p);
/* check whether that file exists */
if (access(configfilebuffer, F_OK))
args->configFile=AQBACKUPC_CFGFILE;
else
args->configFile=configfilebuffer;
}
cfg=Config_new();
rv=Config_ReadFile(cfg,
args->configFile,
CONFIGMODE_ALLOW_GROUPS |
CONFIGMODE_REMOVE_QUOTES |
CONFIGMODE_REMOVE_STARTING_BLANKS |
CONFIGMODE_REMOVE_TRAILING_BLANKS
);
if (rv) {
DBG_ERROR("Could not read configuration file.");
Arguments_free(args);
Config_free(cfg);
return 1;
}
b=AQBackup_new();
/* setup interactor */
ia=AQBInteractor_new();
switch(args->verbosity) {
case 0:
break;
case 1:
AQBInteractor_SetLevel(ia, InteractorLevelVerbous);
break;
case 2:
AQBInteractor_SetLevel(ia, InteractorLevelVeryVerbous);
break;
case 3:
default:
AQBInteractor_SetLevel(ia, InteractorLevelExtremelyVerbous);
break;
} /* switch */
AQBackup_SetInteractor(b, ia);
rv=AQBackup_Init(b, cfg);
if (rv) {
DBG_ERROR("Could not init");
AQBackup_free(b);
Arguments_free(args);
Config_free(cfg);
AQBInteractor_free(ia);
return 2;
}
fp=args->params;
if (fp) {
/* unlink */
args->params=fp->next;
if (strcasecmp(fp->param, "store")==0) {
rv=store(b, args, cfg);
}
else if (strcasecmp(fp->param, "restore")==0) {
rv=restore(b, args, cfg);
}
else if (strcasecmp(fp->param, "diff")==0) {
rv=showdiffs(b, args, cfg);
}
else if (strcasecmp(fp->param, "create")==0) {
rv=createbak(b, args, cfg);
}
else {
fprintf(stderr,
I18N("Unknown command \"%s\"\n"),
fp->param);
rv=1;
}
FreeParam_free(fp);
}
else {
usage(argv[0]);
}
outcfg=Config_new();
if (AQBackup_Fini(b, outcfg)) {
DBG_ERROR("Error deinitializing AqBackup");
}
if (args->allowSaveCfg && rv==0) {
int lrv;
lrv=Config_WriteFile(outcfg,
args->configFile,
CONFIGMODE_ALLOW_GROUPS |
CONFIGMODE_OVERWRITE_VARS |
CONFIGMODE_REMOVE_QUOTES |
CONFIGMODE_REMOVE_STARTING_BLANKS |
CONFIGMODE_REMOVE_TRAILING_BLANKS
);
if (lrv) {
DBG_ERROR("Could not write configuration file.");
rv=9;
}
}
Config_free(outcfg);
AQBackup_free(b);
AQBInteractor_free(ia);
Arguments_free(args);
Config_free(cfg);
return rv;
}
int createbak(AQBACKUP *b, ARGUMENTS *args, CONFIGGROUP *cfg) {
CONFIGGROUP *rg;
char namebuff[256];
if (strlen(args->basedir)==0 ||
strlen(args->user)==0 ||
strlen(args->typ)==0 ||
strlen(args->address)==0) {
fprintf(stderr,
I18N("Please provide at least the following options:\n"
" --basedir\n"
" --user\n"
" --typ\n"
" --address\n"));
return 1;
}
if (Text_Escape(args->basedir, namebuff, sizeof(namebuff))==0) {
DBG_ERROR("Could not escape base dir");
return 1;
}
rg=Config_new();
if (Config_SetValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"basedir",
args->basedir)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
if (Config_SetValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"name",
namebuff)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
if (Config_SetValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"user",
args->user)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
if (Config_SetValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"passwd",
args->passwd)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
if (Config_SetIntValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"ziplevel",
args->ziplevel)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
if (Config_SetValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"type",
args->typ)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
/* setup client arguments */
if (Config_SetValue(rg,
CONFIGMODE_VARIABLE |
CONFIGMODE_NAMECREATE_VARIABLE |
CONFIGMODE_OVERWRITE_VARS,
"client/servercfg",
args->serverConfigFile)) {
DBG_ERROR("Could not set value");
Config_free(rg);
return 1;
}
/* create repository */
if (AQBackup_Create(b, rg, !args->createLocalOnly)) {
DBG_ERROR("Could not create repository");
Config_free(rg);
return 2;
}
/* close it */
if (AQBackup_Close(b)==0) {
/* all is ok, so we may allow to save the configuration file */
args->allowSaveCfg=1;
}
Config_free(rg);
if (args->flags & AQBACKUP_FLAGS_VERBOUS)
fprintf(stdout,
I18N("Repository created.\n"));
return 0;
}
int main(int argc, char** argv)
{
#ifndef CONF_EMBEDDED
if (argc != 2) {
fprintf(stderr, "Usage: %s <config file>\n", argv[0]);
return 1;
}
#else
if (argc != 1) {
fprintf(stderr, "Usage: %s\n", argv[0]);
fprintf(stderr, "Built with an embedded conf.\n");
return 1;
}
char* key = getpass("Password: "******"Password is required to load embedded conf.\n");
return 1;
}
#endif
hline();
printf("%s %s by %s\n", EBBNC_PROGRAM, EBBNC_VERSION, EBBNC_AUTHOR);
hline();
atexit(hline);
printf("Initialising signals ..\n");
InitialiseSignals();
printf("Loading config file ..\n");
#ifndef CONF_EMBEDDED
Config* config = Config_loadFile(argv[1]);
#else
Config* config = Config_loadEmbedded(key);
#endif
if (!config) { return 1; }
if (config->pidFile) {
printf("Checking if bouncer already running ..\n");
int ret = isAlreadyRunning(config->pidFile);
if (ret < 0) {
fprintf(stderr, "Unable to check if already running: %s\n", strerror(errno));
Config_free(&config);
return 1;
}
if (ret != 0) {
fprintf(stderr, "Bouncer already running!\n");
Config_free(&config);
return 1;
}
}
printf("Initialising listening sockets ..\n");
Server* servers = Server_listenAll(config);
if (!servers) {
Config_free(&config);
return 1;
}
printf("Forking into background ..\n");
pid_t pid = daemonise();
if (pid < 0) {
fprintf(stderr, "Failed to fork into background.\n");
Server_freeList(&servers);
Config_free(&config);
return 1;
}
if (pid > 0) {
printf("Bouncer running as PID #%i\n", pid);
if (config->pidFile) {
printf("Creating PID file at %s ..\n", config->pidFile);
if (!createPIDFile(config->pidFile, pid)) {
// this goes to /dev/null at the moment
// this error is not fatal
fprintf(stderr, "Failed to create PID file. This is only a warning.\n");
}
}
hline();
_exit(0);
}
printf("Waiting for connections ..\n");
Server_loop(servers);
Server_freeList(&servers);
Config_free(&config);
return 0;
(void) argc;
}
