release/src-rt/wl/exe/wlu_server_linux.c

   1 /*
   2  * Wl server for linux
   3  *
   4  * Copyright (C) 2010, Broadcom Corporation
   5  * All Rights Reserved.
   6  *
   7  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
   8  * the contents of this file may not be disclosed to third parties, copied
   9  * or duplicated in any form, in whole or in part, without the prior
  10  * written permission of Broadcom Corporation.
  11  *
  12  * $Id: wlu_server_linux.c,v 1.6 2010-02-03 13:09:13 Exp $
  13  */
  14
  15 /* Revision History:Linux port of Remote wl server
  16  *
  17  * Date        Author         Description
  18  *
  19  * 27-Dec-2007 Suganthi        Version 0.1
  20  *
  21  */
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <ctype.h>
  26 #include <malloc.h>
  27 #include <unistd.h>
  28 #include <errno.h>
  29 #include <string.h>
  30 #include <netdb.h>
  31 #include <sys/types.h>
  32 #include <sys/stat.h>
  33 #include <sys/socket.h>
  34 #include <netinet/in.h>
  35 #include <arpa/inet.h>
  36 #include <sys/wait.h>
  37 #include <signal.h>
  38
  39 #include <sys/ioctl.h>
  40 #include <net/if.h>
  41 #ifndef TARGETENV_android
  42 typedef u_int64_t u64;
  43 typedef u_int32_t u32;
  44 typedef u_int16_t u16;
  45 typedef u_int8_t u8;
  46 typedef u_int64_t __u64;
  47 typedef u_int32_t __u32;
  48 typedef u_int16_t __u16;
  49 typedef u_int8_t __u8;
  50 #endif
  51
  52 #include <linux/sockios.h>
  53 #include <linux/ethtool.h>
  54
  55 #include <typedefs.h>
  56 #include <wlioctl.h>
  57 #include <dhdioctl.h>
  58 #include <proto/ethernet.h>
  59 #include <bcmendian.h>
  60 #include <bcmutils.h>
  61 #include <bcmcdc.h>
  62 #include <proto/802.11.h>
  63 #include "wlu_remote.h"
  64
  65
  66 #define DEV_TYPE_LEN    3 /* length for devtype 'wl'/'et' */
  67 #define IOCTL_ERROR    -2
  68 #define BUF_LENGTH              1000
  69
  70 #define dtoh32(i) i
  71
  72
  73 #ifdef IL_BIGENDIAN
  74 bool swap = FALSE;
  75 #endif
  76 const char *rwl_server_name;
  77 void *g_wl_handle;
  78 unsigned short defined_debug = DEBUG_ERR | DEBUG_INFO;
  79 extern int remote_server_exec(int argc, char **argv, void *ifr);
  80
  81 /* Global to have the PID of the current sync command
  82  * This is required in case the sync command fails to respond,
  83  * the alarm handler shall kill the PID upon a timeout
  84  */
  85 int g_shellsync_pid;
  86 unsigned char g_return_stat = 0;
  87
  88 static void
  89 syserr(char *s)
  90 {
  91         fprintf(stderr, "%s: ", rwl_server_name);
  92         perror(s);
  93         exit(errno);
  94 }
  95 /* The handler for DHD commands */
  96 int
  97 dhd_ioctl(void *dhd, int cmd, void *buf, int len, bool set)
  98 {
  99         struct ifreq *ifr = (struct ifreq *) dhd;
 100         dhd_ioctl_t ioc;
 101         int ret = 0;
 102         int s;
 103
 104         /* open socket to kernel */
 105         if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 106                 syserr("socket");
 107
 108         /* do it */
 109         ioc.cmd = cmd;
 110         ioc.buf = buf;
 111         ioc.len = len;
 112         ioc.set = set;
 113         ioc.driver = DHD_IOCTL_MAGIC;
 114         ifr->ifr_data = (caddr_t) &ioc;
 115         if ((ret = ioctl(s, SIOCDEVPRIVATE, ifr)) < 0) {
 116                 if (cmd != DHD_GET_MAGIC) {
 117                         ret = IOCTL_ERROR;
 118                 }
 119         }
 120         /* cleanup */
 121         close(s);
 122         return ret;
 123 }
 124
 125 int
 126 wl_ioctl(void *wl, int cmd, void *buf, int len, bool set)
 127 {
 128         struct ifreq *ifr = (struct ifreq *) wl;
 129         wl_ioctl_t ioc;
 130         int ret = 0;
 131         int s;
 132
 133         /* open socket to kernel */
 134         if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 135                 syserr("socket");
 136
 137         /* do it */
 138         ioc.cmd = cmd;
 139         ioc.buf = buf;
 140         ioc.len = len;
 141         ioc.set = set;
 142         ifr->ifr_data = (caddr_t) &ioc;
 143         if ((ret = ioctl(s, SIOCDEVPRIVATE, ifr)) < 0) {
 144                 if (cmd != WLC_GET_MAGIC) {
 145                         ret = IOCTL_ERROR;
 146                 }
 147         }
 148         /* cleanup */
 149         close(s);
 150         return ret;
 151 }
 152
 153 /* Functions copied from wlu.c to check for the driver adapter in the server machine */
 154 int
 155 wl_check(void *wl)
 156 {
 157         int ret;
 158         int val;
 159
 160         if ((ret = wl_ioctl(wl, WLC_GET_MAGIC, &val, sizeof(int), FALSE) < 0))
 161                 return ret;
 162 #ifdef IL_BIGENDIAN
 163         /* Detect if IOCTL swapping is necessary */
 164         if (val == (int)bcmswap32(WLC_IOCTL_MAGIC))
 165         {
 166                 val = bcmswap32(val);
 167                 swap = TRUE;
 168         }
 169 #endif
 170         if (val != WLC_IOCTL_MAGIC)
 171                 return -1;
 172         if ((ret = wl_ioctl(wl, WLC_GET_VERSION, &val, sizeof(int), FALSE) < 0))
 173                 return ret;
 174         val = dtoh32(val);
 175
 176         if (val > WLC_IOCTL_VERSION) {
 177                 fprintf(stderr, "Version mismatch, please upgrade\n");
 178                 return -1;
 179         }
 180         return 0;
 181 }
 182
 183 static int
 184 wl_get_dev_type(char *name, void *buf, int len)
 185 {
 186         int s;
 187         int ret;
 188         struct ifreq ifr;
 189         struct ethtool_drvinfo info;
 190
 191         /* open socket to kernel */
 192         if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
 193                 syserr("socket");
 194
 195         /* get device type */
 196         memset(&info, 0, sizeof(info));
 197         info.cmd = ETHTOOL_GDRVINFO;
 198         ifr.ifr_data = (caddr_t)&info;
 199         strncpy(ifr.ifr_name, name, IFNAMSIZ);
 200         if ((ret = ioctl(s, SIOCETHTOOL, &ifr)) < 0) {
 201         /* print a good diagnostic if not superuser */
 202                 if (errno == EPERM)
 203                         syserr("wl_get_dev_type");
 204                 *(char *)buf = '\0';
 205         } else {
 206                 strncpy(buf, info.driver, len);
 207         }
 208         close(s);
 209         return ret;
 210 }
 211
 212 static void
 213 wl_find_adapter(struct ifreq *ifr)
 214 {
 215         char proc_net_dev[] = "/proc/net/dev";
 216         FILE *fp;
 217         char buf[BUF_LENGTH], *c, *name;
 218         char dev_type[DEV_TYPE_LEN];
 219
 220         ifr->ifr_name[0] = '\0';
 221
 222         if (!(fp = fopen(proc_net_dev, "r")))
 223                 return;
 224
 225         /* eat first two lines */
 226         if (!fgets(buf, sizeof(buf), fp) ||
 227             !fgets(buf, sizeof(buf), fp)) {
 228                 fclose(fp);
 229                 return;
 230         }
 231
 232         while (fgets(buf, sizeof(buf), fp)) {
 233                 c = buf;
 234                 while (isspace(*c))
 235                         c++;
 236                 if (!(name = strsep(&c, ":")))
 237                         continue;
 238                 strncpy(ifr->ifr_name, name, IFNAMSIZ);
 239                 if (wl_get_dev_type(name, dev_type, DEV_TYPE_LEN) >= 0 &&
 240                         !strncmp(dev_type, "wl", 2))
 241                 if (wl_check((void *) ifr) == 0)
 242                                 break;
 243                 ifr->ifr_name[0] = '\0';
 244         }
 245
 246         fclose(fp);
 247 }
 248
 249 int
 250 wl_get(void *wl, int cmd, void *buf, int len)
 251 {
 252         int error;
 253
 254         error = wl_ioctl(wl, cmd, buf, len, FALSE);
 255
 256         return error;
 257 }
 258
 259 int
 260 wl_set(void *wl, int cmd, void *buf, int len)
 261 {
 262         int error;
 263
 264         error = wl_ioctl(wl,  cmd, buf, len, TRUE);
 265
 266         return error;
 267 }
 268
 269 extern int set_ctrlc;
 270 void handle_ctrlc(int unused)
 271 {
 272         UNUSED_PARAMETER(unused);
 273         set_ctrlc = 1;
 274         return;
 275 }
 276
 277 volatile sig_atomic_t g_sig_chld = 1;
 278 void rwl_chld_handler(int num)
 279 {
 280         int child_status;
 281
 282         UNUSED_PARAMETER(num);
 283         /* g_return_stat is being set with the return status of sh commands */
 284         waitpid(g_shellsync_pid, &child_status, WNOHANG);
 285         if (WIFEXITED(child_status))
 286                 g_return_stat = WEXITSTATUS(child_status);
 287         else if (g_rem_ptr->msg.flags == (unsigned)CTRLC_FLAG)
 288                 g_return_stat = 0;
 289         else
 290                 g_return_stat = 1;
 291         g_sig_chld = 0;
 292 }
 293
 294 /* Alarm handler called after SHELL_TIMEOUT value
 295  * This handler kills the non-responsive shell process
 296  * with the PID value g_shellsync_pid
 297  */
 298 static void
 299 sigalrm_handler(int s)
 300 {
 301         UNUSED_PARAMETER(s);
 302
 303         if (g_shellsync_pid) {
 304                 kill(g_shellsync_pid, SIGINT);
 305         }
 306 #ifdef RWL_SOCKET
 307         g_sig_chld = 0;
 308 #endif
 309 }
 310
 311 static void
 312 def_handler(int s)
 313 {
 314         UNUSED_PARAMETER(s);
 315         kill(g_shellsync_pid, SIGKILL);
 316         exit(0);
 317 }
 318
 319 static void
 320 pipe_handler(int s)
 321 {
 322         UNUSED_PARAMETER(s);
 323         kill(g_shellsync_pid, SIGKILL);
 324 }
 325
 326 int
 327 main(int argc, char **argv)
 328 {
 329         int err = 0;
 330         struct ifreq *ifr;
 331
 332         rwl_server_name = argv[0];
 333
 334         if ((ifr = malloc(sizeof(struct ifreq))) == NULL)
 335         {
 336                 DPRINT_ERR(ERR, "wl_server: Unable to allocate memory for handle\n");
 337                 exit(1);
 338         }
 339         memset(ifr, 0, sizeof(ifr));
 340
 341         /* use default interface */
 342         if (!ifr->ifr_name[0])
 343                 wl_find_adapter(ifr);
 344         /* validate the interface */
 345         if (!ifr->ifr_name[0] || wl_check((void *)ifr)) {
 346                 DPRINT_INFO(OUTPUT, "wl_server: wl driver adapter not found\n");
 347         }
 348         g_wl_handle = ifr;
 349
 350         /* Register signal handlers */
 351         signal(SIGCHLD, rwl_chld_handler);
 352         signal(SIGALRM, sigalrm_handler);
 353         signal(SIGTERM, def_handler);
 354         signal(SIGPIPE, pipe_handler);
 355         signal(SIGABRT, def_handler);
 356 #ifdef RWL_DONGLE
 357         signal(SIGINT, handle_ctrlc);
 358 #endif
 359         /* Main server process for all transport types */
 360         err = remote_server_exec(argc, argv, ifr);
 361
 362         return err;
 363 }
 364
 365 /*
 366  * Funtion to store old interface.
 367  */
 368 void
 369 store_old_interface(void *wl, char *old_intf_name)
 370 {
 371         strcpy(old_intf_name, ((struct ifreq *)wl)->ifr_name);
 372 }
 373
 374 /*
 375  * Function to set interface.
 376  */
 377 int
 378 set_interface(void *wl, char *intf_name)
 379 {
 380         struct ifreq *ifr = (struct ifreq *)wl;
 381
 382         if (strlen(intf_name) != 0) {
 383                 strncpy(ifr->ifr_name, intf_name, strlen(intf_name) + 1);
 384                 return BCME_OK;
 385         }
 386         else {
 387                 DPRINT_DBG(OUTPUT, "Default Interface will be used ... \n");
 388                 return BCME_ERROR;
 389         }
 390 }