void wireless_send_event(struct net_device *	dev,
			 unsigned int		cmd,
			 union iwreq_data *	wrqu,
			 char *			extra)
{
    
    printf("wireless_send_event[0x%x]",cmd);


    if(cmd == IWEVCUSTOM)
    {
        printf("[0x%x] %s\r\n",wrqu->data.flags,extra);
        switch (wrqu->data.flags) 
        {
            case IW_STA_LINKUP_EVENT_FLAG:
                netifapi_netif_common(&wireless_netif, netif_set_link_up, NULL);
#if LWIP_DHCP
                printf("dhcp_start...\r\n");
                netifapi_netif_common(&wireless_netif, NULL, dhcp_start);
#endif 
                break;
            case IW_STA_LINKDOWN_EVENT_FLAG:
                netifapi_netif_common(&wireless_netif, netif_set_link_down, NULL);
#if LWIP_DHCP
                netifapi_netif_common(&wireless_netif, dhcp_stop, NULL);
                netifapi_netif_common(&wireless_netif, netif_set_down, NULL);
                netifapi_netif_set_addr(&wireless_netif, IP_ADDR_ANY, IP_ADDR_ANY, IP_ADDR_ANY);
#endif                 
                break;                  
        }

    }   
}
예제 #2
0
/*********************************************************************************************************
** 函数名称: __tshellIfDown
** 功能描述: 系统命令 "ifdown"
** 输 入  : iArgC         参数个数
**           ppcArgV       参数表
** 输 出  : 0
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT  __tshellIfDown (INT  iArgC, PCHAR  *ppcArgV)
{
    struct netif *netif;

    if (iArgC != 2) {
        fprintf(stderr, "argments error!\n");
        return  (-ERROR_TSHELL_EPARAM);
    }

    netif = netif_find(ppcArgV[1]);                                     /*  查询网络接口                */
    if (netif == LW_NULL) {
        fprintf(stderr, "can not find net interface.\n");
        return  (-ERROR_TSHELL_EPARAM);
    }

    if (!netif_is_up(netif)) {
        fprintf(stderr, "net interface already set down.\n");
        return  (PX_ERROR);
    }

#if LWIP_DHCP > 0
    if (netif->dhcp && netif->dhcp->pcb) {
        netifapi_netif_common(netif, NULL, dhcp_release);               /*  解除 DHCP 租约              */
        netifapi_dhcp_stop(netif);                                      /*  释放资源                    */
    }
#endif                                                                  /*  LWIP_DHCP > 0               */

    netifapi_netif_set_down(netif);                                     /*  禁用网卡                    */

    printf("net interface \"%s\" set down.\n", ppcArgV[1]);
    return  (ERROR_NONE);
}
예제 #3
0
/*********************************************************************************************************
** 函数名称: __tshellIfUp
** 功能描述: 系统命令 "ifup"
** 输 入  : iArgC         参数个数
**           ppcArgV       参数表
** 输 出  : 0
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT  __tshellIfUp (INT  iArgC, PCHAR  *ppcArgV)
{
    struct netif *netif;
    BOOL          bUseDHCP      = LW_FALSE;                             /*  是否使用自动获取 IP         */
    BOOL          bShutDownDHCP = LW_FALSE;                             /*  是否强制关闭 DHCP           */

    if (iArgC < 2) {
        fprintf(stderr, "argments error!\n");
        return  (-ERROR_TSHELL_EPARAM);
    } else if (iArgC > 2) {
        if (lib_strcmp(ppcArgV[2], "-dhcp") == 0) {
            bUseDHCP = LW_TRUE;                                         /*  使用 DHCP 启动              */
        } else if (lib_strcmp(ppcArgV[2], "-nodhcp") == 0) {
            bShutDownDHCP = LW_TRUE;
        }
    }

    netif = netif_find(ppcArgV[1]);                                     /*  查询网络接口                */
    if (netif == LW_NULL) {
        fprintf(stderr, "can not find net interface.\n");
        return  (-ERROR_TSHELL_EPARAM);
    }

    if (netif_is_up(netif)) {                                           /*  网卡是否已经启动            */
#if LWIP_DHCP > 0                                                       /*  首先关闭网卡                */
        if (netif->dhcp && netif->dhcp->pcb) {
            netifapi_netif_common(netif, NULL, dhcp_release);           /*  解除 DHCP 租约              */
            netifapi_dhcp_stop(netif);                                  /*  释放资源                    */
        }
#endif                                                                  /*  LWIP_DHCP > 0               */
        netifapi_netif_set_down(netif);                                 /*  禁用网卡                    */
    }

    netifapi_netif_set_up(netif);                                       /*  启动网卡                    */

#if LWIP_DHCP > 0
    if (bUseDHCP) {
        netif->flags2 |= NETIF_FLAG2_DHCP;                              /*  使用 DHCP 启动              */
    } else if (bShutDownDHCP) {
        netif->flags2 &= ~NETIF_FLAG2_DHCP;                             /*  强制关闭 DHCP               */
    }

    if (netif->flags2 & NETIF_FLAG2_DHCP) {
        ip_addr_t  inaddrNone;

        lib_bzero(&inaddrNone, sizeof(ip_addr_t));
        netifapi_netif_set_addr(netif, &inaddrNone, &inaddrNone, &inaddrNone);
                                                                        /*  所有地址设置为 0            */
        printf("DHCP client starting...\n");
        if (netifapi_dhcp_start(netif) < ERR_OK) {
            printf("DHCP client serious error.\n");
        } else {
            printf("DHCP client start.\n");
        }
    }
#endif                                                                  /*  LWIP_DHCP > 0               */

    printf("net interface \"%s\" set up.\n", ppcArgV[1]);
    return  (ERROR_NONE);
}
예제 #4
0
파일: lwip_if.c 프로젝트: Ga-vin/libsylixos
/*********************************************************************************************************
** 函数名称: if_down
** 功能描述: 关闭网卡
** 输 入  : ifname        if name
** 输 出  : 关闭是否成功
** 全局变量: 
** 调用模块: 
                                           API 函数
*********************************************************************************************************/
LW_API  
INT  if_down (const char *ifname)
{
    INT            iError;
    struct netif  *pnetif;
    
    LWIP_NETIF_LOCK();                                                  /*  进入临界区                  */
    pnetif = netif_find((char *)ifname);
    if (pnetif) {
        if (pnetif->flags & NETIF_FLAG_UP) {
#if LWIP_DHCP > 0
            if (pnetif->dhcp && pnetif->dhcp->pcb) {
                netifapi_netif_common(pnetif, NULL, dhcp_release);      /*  解除 DHCP 租约, 同时停止网卡*/
                netifapi_dhcp_stop(pnetif);                             /*  释放资源                    */
            }
#endif                                                                  /*  LWIP_DHCP > 0               */
            netifapi_netif_set_down(pnetif);                            /*  禁用网卡                    */
            iError = ERROR_NONE;
        } else {
            _ErrorHandle(EALREADY);
            iError = PX_ERROR;
        }
    } else {
        _ErrorHandle(ENXIO);
        iError = PX_ERROR;
    }
    LWIP_NETIF_UNLOCK();                                                /*  退出临界区                  */
    
    return  (iError);
}
/**
  * @brief  Initializes the lwIP stack
  * @param  None
  * @retval None
  */
void Netif_Config(void)
{
    ip_addr_t ipaddr;
    ip_addr_t netmask;
    ip_addr_t gw; 


#if LWIP_DHCP
        ipaddr.addr = 0;
        netmask.addr = 0;
        gw.addr = 0;
#else
        IP4_ADDR(&ipaddr, IP_ADDR0, IP_ADDR1, IP_ADDR2, IP_ADDR3);
        IP4_ADDR(&netmask, NETMASK_ADDR0, NETMASK_ADDR1 , NETMASK_ADDR2, NETMASK_ADDR3);
        IP4_ADDR(&gw, GW_ADDR0, GW_ADDR1, GW_ADDR2, GW_ADDR3);
    
    
        printf("STATIC IP:%d.%d.%d.%d\r\n",ip4_addr1(&ipaddr), ip4_addr2(&ipaddr),ip4_addr3(&ipaddr),ip4_addr4(&ipaddr));
        printf("STATIC GW:%d.%d.%d.%d\r\n",ip4_addr1(&gw), ip4_addr2(&gw),ip4_addr3(&gw),ip4_addr4(&gw));
        printf("STATIC MASK:%d.%d.%d.%d\r\n",ip4_addr1(&netmask), ip4_addr2(&netmask),ip4_addr3(&netmask),ip4_addr4(&netmask));
#endif

        /* - netif_add(struct netif *netif, struct ip_addr *ipaddr,
                  struct ip_addr *netmask, struct ip_addr *gw,
                  void *state, err_t (* init)(struct netif *netif),
                  err_t (* input)(struct pbuf *p, struct netif *netif))
    
         Adds your network interface to the netif_list. Allocate a struct
        netif and pass a pointer to this structure as the first argument.
        Give pointers to cleared ip_addr structures when using DHCP,
        or fill them with sane numbers otherwise. The state pointer may be NULL.
    
        The init function pointer must point to a initialization function for
        your ethernet netif interface. The following code illustrates it's use.*/
        netif_add(&wireless_netif, &ipaddr, &netmask, &gw, NULL, &wlan_ethernetif_init, &tcpip_input);
 
        /*  Registers the default network interface.*/
       netifapi_netif_common(&wireless_netif, netif_set_default, NULL);
       
#if LWIP_DHCP
       netif_set_status_callback(&wireless_netif, netif_status_callback);
#else
       netifapi_netif_common(&wireless_netif, netif_set_up, NULL);
#endif

}
예제 #6
0
/*********************************************************************************************************
** 函数名称: __tshellArp
** 功能描述: 系统命令 "arp"
** 输 入  : iArgC         参数个数
**           ppcArgV       参数表
** 输 出  : 0
** 全局变量:
** 调用模块:
*********************************************************************************************************/
static INT  __tshellArp (INT  iArgC, PCHAR  *ppcArgV)
{
    if (iArgC < 2) {
        fprintf(stderr, "argments error!\n");
        return  (-ERROR_TSHELL_EPARAM);
    }
    
    if (lib_strcmp(ppcArgV[1], "-a") == 0) {                            /*  显示 arp 表                 */
        INT     iFd;
        CHAR    cBuffer[512];
        ssize_t sstNum;
        
        iFd = open("/proc/net/arp", O_RDONLY);
        if (iFd < 0) {
            fprintf(stderr, "can not open /proc/net/arp : %s\n", lib_strerror(errno));
            return  (PX_ERROR);
        }
        
        do {
            sstNum = read(iFd, cBuffer, sizeof(cBuffer));
            if (sstNum > 0) {
                write(STDOUT_FILENO, cBuffer, (size_t)sstNum);
            }
        } while (sstNum > 0);
        
        close(iFd);
        
        return  (ERROR_NONE);
    
    } else if (lib_strcmp(ppcArgV[1], "-s") == 0) {                     /*  加入一个静态转换关系        */
        INT             i;
        INT             iTemp[6];
        ip_addr_t       ipaddr;
        struct eth_addr ethaddr;
        err_t           err;
        
        if (iArgC != 4) {
            fprintf(stderr, "argments error!\n");
            return  (-ERROR_TSHELL_EPARAM);
        }
        
        ipaddr.addr = ipaddr_addr(ppcArgV[2]);
        if (ipaddr.addr == IPADDR_NONE) {
            fprintf(stderr, "bad inet address : %s\n", ppcArgV[2]);
            return  (-ERROR_TSHELL_EPARAM);
        }
        
        if (sscanf(ppcArgV[3], "%02x:%02x:%02x:%02x:%02x:%02x",
                   &iTemp[0], &iTemp[1], &iTemp[2], 
                   &iTemp[3], &iTemp[4], &iTemp[5]) != 6) {
            fprintf(stderr, "bad physical address : %s\n", ppcArgV[3]);
            return  (-ERROR_TSHELL_EPARAM);
        }
        
        for (i = 0; i < 6; i++) {
            ethaddr.addr[i] = (u8_t)iTemp[i];
        }
        
        LOCK_TCPIP_CORE();
        err = etharp_add_static_entry(&ipaddr, &ethaddr);
        UNLOCK_TCPIP_CORE();
        
        return  (err ? PX_ERROR : ERROR_NONE);
    
    } else if (lib_strcmp(ppcArgV[1], "-d") == 0) {                     /*  删除一个静态转换关系        */
        ip_addr_t       ipaddr;
        err_t           err;
        
        if (iArgC != 3) {                                               /*  删除全部转换关系            */
            struct netif *netif;
            
            LWIP_NETIF_LOCK();
            for (netif = netif_list; netif != LW_NULL; netif = netif->next) {
                if (netif->flags & NETIF_FLAG_ETHARP) {
                    netifapi_netif_common(netif, etharp_cleanup_netif, LW_NULL);
                }
            }
            LWIP_NETIF_UNLOCK();
            
            return  (ERROR_NONE);
        }
        
        ipaddr.addr = ipaddr_addr(ppcArgV[2]);
        if (ipaddr.addr == IPADDR_NONE) {
            fprintf(stderr, "bad inet address : %s\n", ppcArgV[2]);
            return  (-ERROR_TSHELL_EPARAM);
        }
        
        LOCK_TCPIP_CORE();
        err = etharp_remove_static_entry(&ipaddr);
        UNLOCK_TCPIP_CORE();
        
        return  (err ? PX_ERROR : ERROR_NONE);
    
    } else {
        fprintf(stderr, "argments error!\n");
        return  (-ERROR_TSHELL_EPARAM);
    }
}