iwspy-sim.c

Go to the documentation of this file.

/* $Id: iwspy-sim.c,v 1.12 2001/07/11 15:12:44 jm Exp $
 * Dynamics iwspy simulator module
 *
 * Dynamic hierarchial IP tunnel
 * Copyright (C) 1998-2000, Dynamics group
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation. See README and COPYING for
 * more details.
 */


#include <malloc.h>
#include <unistd.h>
#include <stdio.h>
#include <getopt.h>
extern char *optarg;
extern int optind, opterr, optopt;
#include <errno.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include <asm/types.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <linux/wireless.h>

#include "dyn_wireless.h"
#include "debug.h"
#include "util.h"

#define DEBUG_FLAG '4'

#define USAGE "iwspy_sim -d <device> [-h] {[<mac_address> "\
"<qualities_file>] .. | -m <mac_address>}\n"
#define MAX_LINE 80
#define MAX_FILES 64

extern int opt_debug;

static struct option const long_options[] =
{
        {"help", no_argument, NULL, 'h'},
        {"device", required_argument, NULL, 'd'},
        {0, 0, 0, 0}
};

int free_nodes(struct quality_values *q)
{
        struct quality_values *t;

        while (q != NULL) {
                t = q;
                q = q->next;
                free(t);
        }

        return 0;
}

/* Format of file (filetype):
     0 = no timestamp, only quality value in one line
     1 = timstamps in seconds and quality value in one line
     2 = timestamps in tens of milliseconds and qual. value in one line
*/
struct quality_values *read_quals(FILE *f, int *ival, int *filetype)
{
        struct quality_values *q, *t;
        char buf[MAX_LINE], hw[ETH_ALEN+1], addr[20];
        int ret, qual;
        unsigned long tstamp;
        

        q = t = dyn_wireless_get_quals_node(NULL);

        /* Read the interval from the first line */
        *ival = 0;
        fgets(buf, MAX_LINE, f);
        ret = sscanf(buf, "# %d %d", ival, filetype);
        if (ret != 2) {
                fprintf(stderr, "Header not found! ´# <ival(in msec)> "
                        "<filetype (0:no timestamps, 1:timestamps in seconds"
                        ", 2:timestamps in tens of milli seconds>'. "
                        "buf: '%s'\n", buf);
                return NULL;
        }
        fgets(buf, MAX_LINE, f);
        ret = sscanf(buf, "# %19s %6s", addr, hw);
        if (ret != 2) {
                fprintf(stderr, "Addresses not found. Should be: "
                        "'# <ip-addr> <hw-addr>'. buf: '%s'\n", buf);
                return NULL;
        }
        /* Read values into structure */
        while (fgets(buf, MAX_LINE, f)) {
                if (*filetype == 0) /* no timestamps */
                        sscanf(buf, "%d", &qual);
                /* timestamps in seconds OR in milliseconds/10 */
                else if (*filetype == 1 || *filetype == 2 || *filetype == 3) 
                        sscanf(buf, "%lu %d", &tstamp, &qual);
                else {
                        fprintf(stderr, "Unknown filetype! (%d)\n", *filetype);
                        return NULL;
                }
                if (qual < 0 || qual > 100) { /* FIX: Exact range */
                        fprintf(stderr, "Invalid quality value! (%lu) "
                                "(%d) '%s'\n", 
                                tstamp, qual, buf);
                        return NULL;
                }
                if (t->num_of_quals >= MAX_NUM_QUALS)
                        t = dyn_wireless_get_quals_node(t);
                /* store value */
                t->sim_quals[t->num_of_quals] = qual;
                t->sim_timestamps[t->num_of_quals] = tstamp;
                t->num_of_quals++;
        }

        return q;
}

FILE *get_file(char *name)
{
        FILE *fd;

        fd = fopen(name, "r");
        if (fd)
                return fd;
        fprintf(stderr, "get_file - %s: %s\n", name, strerror(errno));

        return NULL;    
}

int close_file(FILE *f)
{
        fclose(f);
        return 0;
}

int parse_hw_address(char *string, char *hw)
{
        int ret;

        ret = sscanf(string, "%02x:%02x:%02x:%02x:%02x:%02x", 
                     (unsigned int *)&hw[0], (unsigned int *)&hw[1], 
                     (unsigned int *)&hw[2], (unsigned int *)&hw[3], 
                     (unsigned int *)&hw[4], (unsigned int *)&hw[5]);
        if (ret == 6)
                return 1; /* TRUE */
        
        return 0; /* FALSE */
}

void print_quals(struct quality_values *q)
{
        unsigned long i, j; 

        j = 0;
        while (q != NULL) {
                for (i = 0; i < q->num_of_quals; i++)
                        if (q->sim_timestamps[i] > 0)
                                printf("%-4lu %3d\n", q->sim_timestamps[i], 
                                       q->sim_quals[i]);
                        else
                                printf("%-4ld %3d\n", i + j, q->sim_quals[i]);
                j += q->num_of_quals;
                q = q->next;
        }
}

int parse_pairs(int oindex, int const argc, char **argv, char *hw, 
                FILE *qfile[], int *qfile_index) 
{
        int ret;

        *qfile_index = 0;
        while (oindex < argc-1) {
                printf("oindex = %d, argc = %d, qfile_index = %d\n", 
                       oindex, argc, *qfile_index );
                ret = parse_hw_address(argv[oindex], 
                                       &hw[(*qfile_index)*ETH_ALEN]);
                if (!ret) {
                        fprintf(stderr, "Couldn't parse hw address!\n");
                        printf(USAGE);
                        return 1;
                }
                qfile[*qfile_index] = get_file(argv[oindex+1]);
                if (qfile[*qfile_index] == NULL)
                        return 1;
                (*qfile_index)++;
                if (*qfile_index >= MAX_FILES)
                        return 2;
                oindex += 2;
        }

        return 0;
}

static int feed_quality_values(int sock, char *ifname, char *hw, 
                               FILE *qfile[], int qfile_index)
{
        struct quality_values *quals[MAX_FILES];
        int ivals[MAX_FILES], filetype[MAX_FILES], min_ival = INT_MAX;
        int nodes_left = 1, i, ret, r; 

        /* read values from the file(s) */
        DEBUG(DEBUG_FLAG, "feed_quality_values (%d)\n", qfile_index);
        for (i = 0; i < qfile_index; i++) {
                assert(qfile[i] != NULL);
                quals[i] = read_quals(qfile[i], &ivals[i], &filetype[i]);
                if (quals[i] == NULL) {
                        DEBUG(DEBUG_FLAG, "Reading quals failed! (%d)\n",
                              qfile_index);
                }
                if (ivals[i] < min_ival) 
                        min_ival = ivals[i];
        }

        DEBUG(DEBUG_FLAG, "min_ival = %d, MAX_NUM_QUALS = %d\n", 
              min_ival, MAX_NUM_QUALS);
        while (nodes_left) {
                nodes_left = 0;
                for (i = 0; i < qfile_index; i++) {
                        if (quals[i] == NULL) /* no buffered quality 
                                                 values left for this hw */
                                continue;
                        ret = dyn_wireless_check_simulator(sock, ifname, 
                                                           &hw[i*ETH_ALEN]);
                        if (ret == 3) {
                                DEBUG(DEBUG_FLAG, "Feeding new chunk (%s)\n",
                                      ether_hwtoa((unsigned char *)
                                                  &hw[i*ETH_ALEN]));
                                r = dyn_wireless_set_simulator(sock, ifname, 
                                                               &hw[i*ETH_ALEN],
                                                               quals[i], 
                                                               ivals[i], 
                                                               filetype[i]);
                                if (r)
                                        return r;
                                quals[i] = quals[i]->next;
                                if (quals[i] != NULL)
                                        nodes_left = 1;
                        } else if (ret == 2) {
/*                              DEBUG(DEBUG_FLAG, "No room for new chunk "
                                      "(%s)\n", ether_hwtoa((unsigned char *)
                                      &hw[i*ETH_ALEN]));*/
                                if (quals[i]->next != NULL)
                                        nodes_left = 1;
                        } else if (ret == 1) {
                                DEBUG(DEBUG_FLAG, "Entry not found (%s)\n",
                                      ether_hwtoa((unsigned char *)
                                                  &hw[i*ETH_ALEN]));
                        } else {
                                DEBUG(DEBUG_FLAG, "check_quals returned %d\n",
                                      ret);
                        }

                                
                }
                /* check every 100 msec */
                if (nodes_left)
                        usleep(100000); 
        }

        for (i = 0; i < qfile_index; i++) {
                free_nodes(quals[i]);
        }

        return 0;
}

/* Use iwspy(8) to see monitored entries. Simulator can't be attached
 * to non existing iwspy entry in the kernel. The simulator (if
 * attached to the entry) just bypasses the real quality value and
 * reports the quality value from the attached quality vector
 * (SET_SIMULATOR). NOTICE: Whenever set-iwspy (SIOCSIWSPY) is used,
 * the simulator has to be reinitialized. This is because the
 * set-iwspy ioctl reinitialize all the entries in the kernel.
 * 
 * USAGE:
 *    iwspy-sim -m <mac_address> -d <device> [-f <qualities_file>]
 *
 * If <qualities_file> is given, SET_SIMULATOR is assumed, 
 * otherwise GET_SIMULATOR.  
 */
int main(int argc, char **argv)
{
        int oindex = 0, ret = 1, ret2 = 0;
        char hw[MAX_FILES*ETH_ALEN];
        char get_hw[ETH_ALEN];
        FILE *qfile[MAX_FILES];
        int qfile_index = 0;
        struct quality_values *quals = NULL;
        char ifname[IFNAMSIZ+1];
        signed char c;
        int sock, i;
                
        memset(qfile, 0, sizeof(qfile));
        while ((c = getopt_long(argc, argv, "+d:hm:v", long_options, &oindex)) 
               != EOF) {
                switch (c) {
                case 'd':
                        DEBUG(DEBUG_FLAG, "option d (Device) with value "
                              "'%s'\n", optarg);
                        ret = dyn_wireless_get_ifname(optarg, ifname);
                        break;
                case 'm':
                        DEBUG(DEBUG_FLAG, "option m (Mac address) with value "
                              "'%s'\n", optarg);
                        ret2 = parse_hw_address(optarg, get_hw);
                        break;
                case 'h':
                        printf(USAGE);
                        return 0;
                        break;
                case 'v':
                        opt_debug = 1;
                        break;
                default:
                        fprintf(stderr, "Unknown option %c\n", c);
                        printf(USAGE);
                        break;
                }
        }
        
                
        if (ret) {
                printf("Couldn't parse device name!\n");
                printf(USAGE);
                return 1;
        }


        /* initialize socket */
        sock = dyn_wireless_create_socket();
        if (sock < 0) {
                fprintf(stderr, "Socket creation failed (%s)\n",
                        strerror(errno));
                return 1;
        }

        if (ret2) {
                /* GET_SIMULATOR */
                DEBUG(DEBUG_FLAG, "GET\n");
                quals = dyn_wireless_get_simulator(sock, ifname, get_hw);
                print_quals(quals);
                free_nodes(quals);
        } else {
                /* SET_SIMULATOR */
                /* parse hw address and qualities file pairs */
                DEBUG(DEBUG_FLAG, "SET\n");
                if (parse_pairs(optind, argc, argv, hw, qfile, &qfile_index)) {
                        fprintf(stderr, "Command line parsing failed!\n");
                        return 1;
                }
                feed_quality_values(sock, ifname, hw, qfile, qfile_index);
        }

        for (i = 0; qfile[i] != NULL; i++)
                close_file(qfile[i]);
        return 0;
}

---