visibility.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10

    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2010-2011 Monthadar Al Jaberi, TerraNet AB
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *    notice, this list of conditions and the following disclaimer,
   12  *    without modification.
   13  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
   14  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
   15  *    redistribution must be conditioned upon including a substantially
   16  *    similar Disclaimer requirement for further binary redistribution.
   17  *
   18  * NO WARRANTY
   19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   21  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
   22  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
   23  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
   24  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
   27  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
   29  * THE POSSIBILITY OF SUCH DAMAGES.
   30  *
   31  * $FreeBSD$
   32  */
   33 #include <sys/param.h>
   34 #include <sys/module.h>
   35 #include <sys/kernel.h>
   36 #include <sys/systm.h>
   37 #include <sys/sysctl.h>
   38 #include <sys/mbuf.h>
   39 #include <sys/malloc.h>
   40 #include <sys/lock.h>
   41 #include <sys/mutex.h>
   42 #include <sys/proc.h>
   43 #include <sys/ucred.h>
   44 #include <sys/jail.h>
   45 
   46 #include <sys/sockio.h>
   47 #include <sys/socket.h>
   48 #include <sys/socketvar.h>
   49 #include <sys/errno.h>
   50 #include <sys/callout.h>
   51 #include <sys/endian.h>
   52 #include <sys/kthread.h>
   53 #include <sys/taskqueue.h>
   54 #include <sys/priv.h>
   55 #include <sys/sysctl.h>
   56 
   57 #include <machine/bus.h>
   58 
   59 #include <net/if.h>
   60 #include <net/if_dl.h>
   61 #include <net/if_media.h>
   62 #include <net/if_types.h>
   63 #include <net/if_arp.h>
   64 #include <net/ethernet.h>
   65 #include <net/if_llc.h>
   66 #include <net/vnet.h>
   67 
   68 #include <net80211/ieee80211_var.h>
   69 #include <net80211/ieee80211_regdomain.h>
   70 
   71 #include <net/bpf.h>
   72 
   73 #include <sys/errno.h>
   74 #include <sys/conf.h>   /* cdevsw struct */
   75 #include <sys/uio.h>    /* uio struct */
   76 
   77 #include <netinet/in.h>
   78 #include <netinet/if_ether.h>
   79 
   80 #include "visibility.h"
   81 
   82 /* Function prototypes */
   83 static d_ioctl_t        vis_ioctl;
   84 
   85 static struct cdevsw vis_cdevsw = {
   86         .d_version =    D_VERSION,
   87         .d_flags =      0,
   88         .d_ioctl =      vis_ioctl,
   89         .d_name =       "visctl",
   90 };
   91 
   92 void
   93 visibility_init(struct wtap_plugin *plugin)
   94 {
   95         struct visibility_plugin *vis_plugin;
   96 
   97         vis_plugin = (struct visibility_plugin *) plugin;
   98         plugin->wp_sdev = make_dev(&vis_cdevsw,0,UID_ROOT,GID_WHEEL,0600,
   99             (const char *)"visctl");
  100         plugin->wp_sdev->si_drv1 = vis_plugin;
  101         mtx_init(&vis_plugin->pl_mtx, "visibility_plugin mtx",
  102             NULL, MTX_DEF | MTX_RECURSE);
  103         printf("Using visibility wtap plugin...\n");
  104 }
  105 
  106 void
  107 visibility_deinit(struct wtap_plugin *plugin)
  108 {
  109         struct visibility_plugin *vis_plugin;
  110 
  111         vis_plugin = (struct visibility_plugin *) plugin;
  112         destroy_dev(plugin->wp_sdev);
  113         mtx_destroy(&vis_plugin->pl_mtx);
  114         free(vis_plugin, M_WTAP_PLUGIN);
  115         printf("Removing visibility wtap plugin...\n");
  116 }
  117 
  118 /* We need to use a mutex lock when we read out a visibility map
  119  * and when we change visibility map from user space through IOCTL
  120  */
  121 void
  122 visibility_work(struct wtap_plugin *plugin, struct packet *p)
  123 {
  124         struct visibility_plugin *vis_plugin =
  125             (struct visibility_plugin *) plugin;
  126         struct wtap_hal *hal = (struct wtap_hal *)vis_plugin->base.wp_hal;
  127         struct vis_map *map;
  128 
  129         KASSERT(mtod(p->m, const char *) != (const char *) 0xdeadc0de ||
  130             mtod(p->m, const char *) != NULL,
  131             ("[%s] got a corrupt packet from master queue, p->m=%p, p->id=%d\n",
  132             __func__, p->m, p->id));
  133         DWTAP_PRINTF("[%d] BROADCASTING m=%p\n", p->id, p->m);
  134         mtx_lock(&vis_plugin->pl_mtx);
  135         map = &vis_plugin->pl_node[p->id];
  136         mtx_unlock(&vis_plugin->pl_mtx);
  137 
  138         /* This is O(n*n) which is not optimal for large
  139          * number of nodes. Another way of doing it is
  140          * creating groups of nodes that hear each other.
  141          * Atleast for this simple static node plugin.
  142          */
  143         for(int i=0; i<ARRAY_SIZE; ++i){
  144                 uint32_t index = map->map[i];
  145                 for(int j=0; j<32; ++j){
  146                         int vis = index & 0x01;
  147                         if(vis){
  148                                 int k = i*ARRAY_SIZE + j;
  149                                 if(hal->hal_devs[k] != NULL
  150                                     && hal->hal_devs[k]->up == 1){
  151                                         struct wtap_softc *sc =
  152                                             hal->hal_devs[k];
  153                                         struct mbuf *m =
  154                                             m_dup(p->m, M_NOWAIT);
  155                                         DWTAP_PRINTF("[%d] duplicated old_m=%p"
  156                                             "to new_m=%p\n", p->id, p->m, m);
  157 #if 0
  158                                         printf("[%d] sending to %d\n",
  159                                             p->id, k);
  160 #endif
  161                                         wtap_inject(sc, m);
  162                                 }
  163                         }
  164                         index = index >> 1;
  165                 }
  166         }
  167 }
  168 
  169 static void
  170 add_link(struct visibility_plugin *vis_plugin, struct link *l)
  171 {
  172 
  173         mtx_lock(&vis_plugin->pl_mtx);
  174         struct vis_map *map = &vis_plugin->pl_node[l->id1];
  175         int index = l->id2/ARRAY_SIZE;
  176         int bit = l->id2 % ARRAY_SIZE;
  177         uint32_t value = 1 << bit;
  178         map->map[index] = map->map[index] | value;
  179         mtx_unlock(&vis_plugin->pl_mtx);
  180 #if 0
  181         printf("l->id1=%d, l->id2=%d, map->map[%d] = %u, bit=%d\n",
  182             l->id1, l->id2, index, map->map[index], bit);
  183 #endif
  184 }
  185 
  186 static void
  187 del_link(struct visibility_plugin *vis_plugin, struct link *l)
  188 {
  189 
  190         mtx_lock(&vis_plugin->pl_mtx);
  191         struct vis_map *map = &vis_plugin->pl_node[l->id1];
  192         int index = l->id2/ARRAY_SIZE;
  193         int bit = l->id2 % ARRAY_SIZE;
  194         uint32_t value = 1 << bit;
  195         map->map[index] = map->map[index] & ~value;
  196         mtx_unlock(&vis_plugin->pl_mtx);
  197 #if 0
  198         printf("map->map[index] = %u\n", map->map[index]);
  199 #endif
  200 }
  201 
  202 int
  203 vis_ioctl(struct cdev *sdev, u_long cmd, caddr_t data,
  204     int fflag, struct thread *td)
  205 {
  206         struct visibility_plugin *vis_plugin =
  207             (struct visibility_plugin *) sdev->si_drv1;
  208         struct wtap_hal *hal = vis_plugin->base.wp_hal;
  209         struct link l;
  210         int op;
  211         int error = 0;
  212 
  213         CURVNET_SET(CRED_TO_VNET(curthread->td_ucred));
  214         switch(cmd) {
  215         case VISIOCTLOPEN:
  216                 op =  *(int *)data; 
  217                 if(op == 0)
  218                         medium_close(hal->hal_md);
  219                 else
  220                         medium_open(hal->hal_md);
  221                 break;
  222         case VISIOCTLLINK:
  223                 l = *(struct link *)data;
  224                 if(l.op == 0)
  225                         del_link(vis_plugin, &l);
  226                 else
  227                         add_link(vis_plugin, &l);
  228 #if 0
  229                 printf("op=%d, id1=%d, id2=%d\n", l.op, l.id1, l.id2);
  230 #endif
  231                 break;
  232         default:
  233                 DWTAP_PRINTF("Unknown WTAP IOCTL\n");
  234                 error = EINVAL;
  235         }
  236 
  237         CURVNET_RESTORE();
  238         return error;
  239 }

Cache object: c7e1893f53c5cd6f937b5f1672e53032

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.

FreeBSD/Linux Kernel Cross Reference sys/dev/wtap/plugins/visibility.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/wtap/plugins/visibility.c