release/src-rt/wl/nas/nas_rte.c

   1 /* Network Authentication Service deamon (RTE)
   2  *
   3  * Copyright (C) 2010, Broadcom Corporation
   4  * All Rights Reserved.
   5  *
   6  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
   7  * the contents of this file may not be disclosed to third parties, copied
   8  * or duplicated in any form, in whole or in part, without the prior
   9  * written permission of Broadcom Corporation.
  10  *
  11  * $Id: nas_rte.c 241388 2011-02-18 03:33:22Z stakita $
  12  */
  13
  14
  15 #include <typedefs.h>
  16 #include <time.h>
  17 #include <osl.h>
  18 #include <hndrte.h>
  19 #include <wlutils.h>
  20 #include <assert.h>
  21
  22 #include <bcmcrypto/md5.h>
  23
  24 #include <relay_rte.h>
  25
  26 #include "nas_wksp.h"
  27
  28 /* RTE Layer 2 protocol handlers */
  29 /* WPA */
  30 static bool wpa_recv(hndrte_dev_t *dev, void *ctx, struct lbuf *lb, uint16 ethtype);
  31 static ethtype_handler_t wpa_handler = {NULL, ETHER_TYPE_BRCM, wpa_recv, };
  32
  33 extern void bsp_reboot(void);
  34
  35 hndrte_dev_t *wldev;
  36 int naswl_sendpkt(struct lbuf *lbf);
  37
  38
  39 void nas_sleep_ms(uint ms);
  40 void nas_rand128(uint8 *rand128);
  41 void nas_reset_board(void);
  42 static int nas_get_wlrand(char *ifname, uint16 *val);
  43 int nas_init(int argc, char *argv[]);
  44 void nasStart(char *type);
  45
  46
  47 /* Might be better to put this somewhere else, this doesn't have to be NAS
  48  * specific - it's implementing POSIX-like functionality
  49  */
  50 time_t
  51 time(time_t *t)
  52 {
  53         if (!t)
  54                 return 0;
  55
  56         *t = hndrte_time();
  57         return *t;
  58 }
  59
  60 /* Might be better to put this somewhere else, this doesn't have to be NAS
  61  * specific - it's implementing POSIX-like functionality
  62  */
  63 int
  64 gettimeofday(struct timeval *tv, struct timezone *tz)
  65 {
  66         uint32 milliseconds = hndrte_time();
  67
  68         memset(tz, 0, sizeof(struct timezone));
  69         memset(tv, 0, sizeof(struct timeval));
  70
  71         tv->tv_sec = milliseconds / 1000;
  72
  73         return 0;
  74 }
  75
  76
  77 int
  78 naswl_sendpkt(struct lbuf *lbf)
  79 {
  80         return wldev->dev_funcs->xmit(NULL, wldev, lbf);
  81 }
  82
  83
  84 void
  85 nas_sleep_ms(uint ms)
  86 {
  87         hndrte_delay(ms*1000);
  88 }
  89
  90 static int
  91 nas_get_wlrand(char *ifname, uint16 *val)
  92 {
  93         char buf[WLC_IOCTL_SMLEN];
  94         int ret;
  95
  96         strcpy(buf, "rand");
  97         if ((ret = wl_ioctl(ifname, WLC_GET_VAR, buf, sizeof(buf))))
  98                 return ret;
  99
 100         *val = *(uint16 *)buf;
 101         return 0;
 102 }
 103
 104 void
 105 nas_rand128(uint8 *rand128)
 106 {
 107         struct timeval tv;
 108         struct timezone tz;
 109         uint16 rand_val;
 110         MD5_CTX md5;
 111
 112         gettimeofday(&tv, &tz);
 113
 114         if (nas_get_wlrand("wl0", &rand_val) == 0)
 115                 tv.tv_sec ^= rand_val;
 116         else
 117                 NASDBG("NAS - nas_rad128 couldn't get random number from WL!!!\n");
 118         MD5Init(&md5);
 119         MD5Update(&md5, (unsigned char *) &tv, sizeof(tv));
 120         MD5Update(&md5, (unsigned char *) &tz, sizeof(tz));
 121         MD5Final(rand128, &md5);
 122 }
 123
 124 /* establish connection to receive wpa message */
 125 int
 126 nas_wksp_open_wpa(nas_wksp_t *nwksp)
 127 {
 128         /* set the context for this handler to use */
 129         wpa_handler.ctx = nwksp;
 130
 131         /* Register with the relay to receive  for packets */
 132         bcmrelay.dev_funcs->ioctl(&bcmrelay, RELAY_PROTOREGISTER,
 133                                   &wpa_handler,
 134                                   sizeof(ethtype_handler_t *), NULL, NULL, 0);
 135
 136         NASDBG("%s: registered with relay for wpa messages\n", nwksp->lan);
 137         return 0;
 138 }
 139
 140 static bool
 141 wpa_recv(hndrte_dev_t *dev, void *ctx, struct lbuf *lb, uint16 ethtype)
 142 {
 143         uint8 *pkt = lb->data;
 144         int len = lb->len;
 145         nas_wksp_t *nwksp = (nas_wksp_t *)ctx;
 146         nas_wpa_cb_t *nwcb;
 147         bcm_event_t *pvt_data = (bcm_event_t *)pkt;
 148
 149         /* recv wpa message from relay */
 150         /* validate the recv packet */
 151         if (nas_validate_wlpvt_message(len, pkt) != 0) {
 152                 goto error0;
 153         }
 154         pvt_data  = (bcm_event_t *)pkt;
 155
 156         nwcb = nas_wksp_find_nwcb_by_mac(nwksp, pvt_data->eth.ether_dhost,
 157                                          pvt_data->event.ifname);
 158
 159         if (nwcb && !(nwcb->flags & NAS_WPA_CB_FLAG_ERROR))
 160                 nas_handle_wlpvt_messages(nwcb, (void *)pvt_data, len, 1);
 161
 162         lb_free(lb);
 163         return TRUE;
 164
 165 error0:
 166         /* way to say not our message */
 167         NASDBG("Not a WPA NAS packet, returning pkt to relay 0x%p\n", lb);
 168         return FALSE;
 169 }
 170
 171 /* transmit preauth message thru the relay */
 172 int
 173 nas_preauth_send_packet(nas_t *nas, struct iovec *frags, int nfrags)
 174 {
 175         printf("\nUnsupported - nas_preauth_send_packet\n\n");
 176         return 1;
 177 }
 178
 179
 180 /* open connections to network to receive/send eapol packets */
 181 int
 182 nas_wksp_open_eapol(nas_wksp_t *nwksp)
 183 {
 184         /* not needed for HNDRTE - all EAPOL messages are
 185          * encapsulated in BRCM ethertype from wl
 186          */
 187         return 0;
 188 }
 189
 190 /* send eapol packet out to the net */
 191 int
 192 nas_eapol_send_packet(nas_t *nas, struct iovec *frags, int nfrags)
 193 {
 194         struct lbuf *lbf;
 195         int i, count;
 196         uchar *buf;
 197
 198         /* Convert iov to mbuf chain */
 199         if (nfrags > 1)
 200         {
 201                 for (i = 0, count = 0; i < nfrags; i++)
 202                         count += frags[i].iov_len;
 203                 if (!(lbf = lb_alloc(count, __FILE__, __LINE__)))
 204                 {
 205                         NASDBG("%s: lb_alloc error\n", nas->interface);
 206                         return 1;
 207                 }
 208                 buf = lbf->data;
 209                 for (i = 0, count = 0; i < nfrags; i++)
 210                 {
 211                         memcpy(&buf[count], frags[i].iov_base, frags[i].iov_len);
 212                         count += frags[i].iov_len;
 213                 }
 214         }
 215         else if (nfrags == 1)
 216         {
 217                 lbf = lb_alloc(frags[0].iov_len, __FILE__, __LINE__);
 218                 memcpy(lbf->data, frags[0].iov_base, frags[0].iov_len);
 219                 NASDBG("%s: nfrags = 1 and Length of Message %d\n",
 220                         nas->interface,  frags[0].iov_len);
 221         }
 222         else
 223         {
 224                 NASDBG("%s: nfrags == 0 error\n", nas->interface);
 225                 return 1;
 226         }
 227         if (!lbf)
 228         {
 229                 NASDBG("%s: failed to allocate mblk\n", nas->interface);
 230                 return 1;
 231         }
 232
 233         /* send packet to network thru the interface */
 234         return naswl_sendpkt(lbf);
 235 }
 236
 237 void
 238 nas_reset_board(void)
 239 {
 240         bsp_reboot();
 241         return;
 242 }
 243
 244 /* nas task entry */
 245 int
 246 nas_init(int argc, char *argv[])
 247 {
 248         nas_wksp_t *nwksp = NULL;
 249
 250         /* alloc nas/wpa work space */
 251         if (!(nwksp = nas_wksp_alloc_workspace())) {
 252                 NASMSG("Unable to allocate memory. Quitting...\n");
 253                 goto exit0;
 254         }
 255
 256         /* init nas/wpa work space */
 257         if (nas_wksp_parse_cmd_line(argc, argv, nwksp)) {
 258                 NASMSG("Command line parsing error. Quitting...\n");
 259                 goto exit1;
 260         }
 261         if (!nwksp->nwcbs) {
 262                 NASMSG("No interface specified. Quitting...\n");
 263                 goto exit1;
 264         }
 265
 266         /* init nas */
 267         if (nas_wksp_init(nwksp)) {
 268                 NASMSG("Unable to initialize NAS. Quitting...\n");
 269                 goto exit1;
 270         }
 271         goto exit0;
 272
 273         /* error handling */
 274 exit1:
 275         nas_wksp_free_workspace(nwksp);
 276 exit0:
 277         return 0;
 278 }
 279
 280 void
 281 nasStart(char *type)
 282 {
 283         static char *nas_argv[NAS_WKSP_MAX_CMD_LINE_ARGS];
 284         int nas_argc = NAS_WKSP_MAX_CMD_LINE_ARGS;
 285
 286         wldev = hndrte_get_dev("wl0");
 287
 288         if (nas_wksp_build_cmd_line(type, NULL, &nas_argc, nas_argv))
 289                 NASDBG("NAS error - couldn't build command line.\n");
 290         else if (nas_init(nas_argc, nas_argv) != 0)
 291                 NASDBG("NAS error - init failed.\n");
 292
 293         return;
 294 }