diff --git a/RTL00_SDKV35a/component/common/network/netbios/netbios.c b/RTL00_SDKV35a/component/common/network/netbios/netbios.c new file mode 100644 index 0000000..78e5a90 --- /dev/null +++ b/RTL00_SDKV35a/component/common/network/netbios/netbios.c @@ -0,0 +1,396 @@ +/** + * @file + * NetBIOS name service sample + * https://tools.ietf.org/html/rfc1002 + * Modified for RTL871x pvvx + */ + +#if 1 // def USE_NETBIOS + +/* + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT + * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT + * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING + * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * This file is part of the lwIP TCP/IP stack. + * + */ +#include "rtl8195a/rtl_common.h" +#include "rtl8195a.h" + +#include "lwip/opt.h" +#include "netbios/netbios.h" + +#if LWIP_UDP /* don't build if not configured for use in lwipopts.h */ + +#include + +#include "ipv4/lwip/ip.h" +#include "lwip/udp.h" +#include "lwip/netif.h" +#include "lwip_netconf.h" +#include "rtl8195a/esp_comp.h" + +#define NETBIOS_CODE_ATTR +#define NETBIOS_DATA_ATTR + +//extern struct netif xnetif[NET_IF_NUM]; + +#define NBS_DEF_NAME "rtl871x" + +/** This is an example implementation of a NetBIOS name server. + * It responds to name queries for a configurable name. + * Name resolving is not supported. + * + * Note that the device doesn't broadcast it's own name so can't + * detect duplicate names! + */ + +/** Since there's no standard function for case-insensitive string comparision, + * we need another define here: + * define this to stricmp() for windows or strcasecmp() for linux. + * If not defined, comparision is case sensitive and NETBIOS_LWIP_NAME must be + * uppercase + */ +#ifndef NETBIOS_STRCMP +#define NETBIOS_STRCMP(str1, str2) os_strcmp(str1, str2) +#endif + +/** default port number for "NetBIOS Name service */ +//#define NETBIOS_PORT 137 +/** NetBIOS name of LWIP device + * This must be uppercase until NETBIOS_STRCMP() is defined to a string + * comparision function that is case insensitive. + * If you want to use the netif's hostname, use this (with LWIP_NETIF_HOSTNAME): + * (ip_current_netif() != NULL ? ip_current_netif()->hostname != NULL ? ip_current_netif()->hostname : "" : "") + */ + +/** size of a NetBIOS name */ +//#define NETBIOS_NAME_LEN 16 // in netbios.h +char netbios_name[NET_IF_NUM][NETBIOS_NAME_LEN + 1]; // default netifs: 0 - SoftAP, 1 - Station, 2 - Ethernet + +/** The Time-To-Live for NetBIOS name responds (in seconds) + * Default is 300000 seconds (3 days, 11 hours, 20 minutes) */ +#define NETBIOS_NAME_TTL 300000 + +/** NetBIOS header flags */ +#define NETB_HFLAG_RESPONSE 0x8000U +#define NETB_HFLAG_OPCODE 0x7800U +#define NETB_HFLAG_OPCODE_NAME_QUERY 0x0000U +#define NETB_HFLAG_AUTHORATIVE 0x0400U +#define NETB_HFLAG_TRUNCATED 0x0200U +#define NETB_HFLAG_RECURS_DESIRED 0x0100U +#define NETB_HFLAG_RECURS_AVAILABLE 0x0080U +#define NETB_HFLAG_BROADCAST 0x0010U +#define NETB_HFLAG_REPLYCODE 0x0008U +#define NETB_HFLAG_REPLYCODE_NOERROR 0x0000U + +/** NetBIOS name flags */ +#define NETB_NFLAG_UNIQUE 0x8000U +#define NETB_NFLAG_NODETYPE 0x6000U +#define NETB_NFLAG_NODETYPE_HNODE 0x6000U +#define NETB_NFLAG_NODETYPE_MNODE 0x4000U +#define NETB_NFLAG_NODETYPE_PNODE 0x2000U +#define NETB_NFLAG_NODETYPE_BNODE 0x0000U + +/** NetBIOS message header */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_hdr { + PACK_STRUCT_FIELD(u16_t trans_id); + PACK_STRUCT_FIELD(u16_t flags); + PACK_STRUCT_FIELD(u16_t questions); + PACK_STRUCT_FIELD(u16_t answerRRs); + PACK_STRUCT_FIELD(u16_t authorityRRs); + PACK_STRUCT_FIELD(u16_t additionalRRs); +}PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** NetBIOS message name part */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_name_hdr { + PACK_STRUCT_FIELD(u8_t nametype); + PACK_STRUCT_FIELD(u8_t encname[(NETBIOS_NAME_LEN*2)+1]); + PACK_STRUCT_FIELD(u16_t type); + PACK_STRUCT_FIELD(u16_t cls); + PACK_STRUCT_FIELD(u32_t ttl); + PACK_STRUCT_FIELD(u16_t datalen); + PACK_STRUCT_FIELD(u16_t flags); + PACK_STRUCT_FIELD(ip_addr_p_t addr); +}PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** NetBIOS message */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_resp { + struct netbios_hdr resp_hdr; + struct netbios_name_hdr resp_name; +}PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** NetBIOS decoding name */ +static int8_t NETBIOS_CODE_ATTR NBNS_decode(char *dst, char *src) +{ + uint8_t i, j; + char c; + + for(i=0, j=0; i<15; i++) + { + c = (src[j++]-'A')<<4; + c |= (src[j++]-'A')<<0; + if(c == ' ') + { + break; + } + dst[i] = toupper(c); + } + dst[i] = 0; + + return (((src[30]-'A')<<4)|(src[31]-'A')); // 0x00 = Workstation +} + +#if 0 +/** NetBIOS encoding name */ +static void NBNS_encode(char *dst, char *src, uint8_t type) +{ + uint8_t i, j; + char c; + + //encode name + for(i=0, j=0; (i<15) && src[i]; i++) + { + c = toupper(src[i]); + dst[j++] = 'A'+((c>>4)&0x0f); + dst[j++] = 'A'+((c>>0)&0x0f); + } + + //add spaces + for(; i<15; i++) + { + dst[j++] = 'A'+((' '>>4)&0x0f); + dst[j++] = 'A'+((' '>>0)&0x0f); + } + + //set type (0x00 = Workstation) + dst[j++] = 'A'+((type>>4)&0x0f); + dst[j++] = 'A'+((type>>0)&0x0f); +} +#endif + +/** NetBIOS Name service recv callback */ +static void NETBIOS_CODE_ATTR +netbios_recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, ip_addr_t *addr, + u16_t port) { + LWIP_UNUSED_ARG(arg); + /* if packet is valid */ + if (p != NULL && p->len >= sizeof(struct netbios_hdr) + sizeof(struct netbios_name_hdr) - 12) { + if (current_netif != NULL && current_netif->num < NET_IF_NUM) { + uint32 ip = current_netif->ip_addr.addr; + char *curbiosname = netbios_name[current_netif->num]; + if (curbiosname[0] != '\0' && ip != NULL + /* we only answer if we got a default interface */ + && (((ip ^ addr->addr) & current_netif->netmask.addr) == 0)) { // запрет ответа другой подсети +#if DEBUGSOO > 3 + os_printf("nbns: " IPSTR ",\t'%s'\n", IP2STR(&ip), curbiosname); +#endif + char netbiosname[NETBIOS_NAME_LEN + 1]; + os_memset(netbiosname, 0, sizeof(netbiosname)); + struct netbios_hdr* netbios_hdr = + (struct netbios_hdr*) p->payload; + struct netbios_name_hdr* netbios_name_hdr = + (struct netbios_name_hdr*) (netbios_hdr + 1); + /* @todo: do we need to check answerRRs/authorityRRs/additionalRRs? */ + /* if the packet is a NetBIOS name query question */ + if (((netbios_hdr->flags & PP_NTOHS(NETB_HFLAG_OPCODE)) + == PP_NTOHS(NETB_HFLAG_OPCODE_NAME_QUERY)) + && ((netbios_hdr->flags & PP_NTOHS(NETB_HFLAG_RESPONSE)) + == 0) + && (netbios_hdr->questions == PP_NTOHS(1)) + && (netbios_name_hdr->cls == PP_NTOHS(1)) + && (netbios_name_hdr->type == PP_NTOHS(0x20))) { + /* decode the NetBIOS name */ + int8_t ret = NBNS_decode(netbiosname, + (char*) (netbios_name_hdr->encname)); + /* if the packet is for us */ +#if DEBUGSOO > 2 + if (ret == 0) os_printf("nbns: get " IPSTR ", '%s'\n", IP2STR(addr), + netbiosname); +#endif + if (ret == 0 && NETBIOS_STRCMP(curbiosname, netbiosname) == 0) { // netbiosname[0] == '*' +#if DEBUGSOO > 1 + os_printf("nbns: out " IPSTR ", '%s'\n", IP2STR(&ip), + curbiosname); +#endif + struct pbuf *q; + struct netbios_resp *resp; + + q = pbuf_alloc(PBUF_TRANSPORT, + sizeof(struct netbios_resp), PBUF_RAM); + if (q != NULL) { + resp = (struct netbios_resp*) q->payload; + + /* prepare NetBIOS header response */ + resp->resp_hdr.trans_id = netbios_hdr->trans_id; + resp->resp_hdr.flags = + PP_HTONS( + NETB_HFLAG_RESPONSE | NETB_HFLAG_OPCODE_NAME_QUERY | NETB_HFLAG_AUTHORATIVE | NETB_HFLAG_RECURS_DESIRED); + resp->resp_hdr.questions = 0; + resp->resp_hdr.answerRRs = PP_HTONS(1); + resp->resp_hdr.authorityRRs = 0; + resp->resp_hdr.additionalRRs = 0; + + /* prepare NetBIOS header datas */ + MEMCPY(resp->resp_name.encname, + netbios_name_hdr->encname, + sizeof(netbios_name_hdr->encname)); + resp->resp_name.nametype = + netbios_name_hdr->nametype; + resp->resp_name.type = netbios_name_hdr->type; + resp->resp_name.cls = netbios_name_hdr->cls; + resp->resp_name.ttl = PP_HTONL(NETBIOS_NAME_TTL); + resp->resp_name.datalen = PP_HTONS( + sizeof(resp->resp_name.flags) + + sizeof(resp->resp_name.addr)); + resp->resp_name.flags = PP_HTONS( + NETB_NFLAG_NODETYPE_BNODE); + + resp->resp_name.addr.addr = ip; // netif_default->ip_addr.addr; + /* send the NetBIOS response */ + udp_sendto(upcb, q, addr, port); + /* free the "reference" pbuf */ + pbuf_free(q); + } + } + } + } + } + /* free the pbuf */ + pbuf_free(p); + } +} + +struct udp_pcb * NETBIOS_CODE_ATTR netbios_pcb(void) { + struct udp_pcb *pcb; + for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) { + if (pcb->local_port == NETBIOS_PORT) + return pcb; + } + return NULL; +} + +/* default netifs/interfacenum: 0 - SoftAP, 1 - Station, 2 - Ethernet */ + +bool NETBIOS_CODE_ATTR netbios_set_name(unsigned char interfacenum, char * name) { + if (interfacenum >= NET_IF_NUM) + return false; + int i; + uint8 * pnbn = netbios_name[interfacenum]; + uint8 * pmane = name; + if (name != NULL) { + for (i = 0; i < NETBIOS_NAME_LEN; i++) { + if (*pmane < ' ') + break; + else if (*pmane == ' ') + *pnbn++ = '_'; + else + *pnbn++ = toupper(*pmane); + pmane++; + }; + }; + *pnbn = '\0'; + return true; +} + +bool NETBIOS_CODE_ATTR netbios_off(void) { + struct udp_pcb *pcb = netbios_pcb(); + if (pcb == NULL) + return false; + udp_remove(pcb); + return true; +} + +void NETBIOS_CODE_ATTR netbios_init(void) { + struct udp_pcb *pcb; + char buf[] = "a"NBS_DEF_NAME; +#if NET_IF_NUM > 0 + if (netbios_name[0][0] == 0) { + buf[0] = 'a'; // SoftAP + netbios_set_name(0, buf); + } +#endif +#if NET_IF_NUM > 1 + if (netbios_name[1][0] == 0) { + buf[0] = 's'; // Station + netbios_set_name(1, buf); + } +#endif +#if NET_IF_NUM > 2 + if (netbios_name[2][0] == 0) { + buf[0] = 'e'; // Ethernet + netbios_set_name(2, buf); + } +#endif +#if NET_IF_NUM > 3 +#error "NBNS: Add NETBIOS Name!" +#endif + if (netbios_pcb() != NULL) + return; + +#if DEBUGSOO > 1 +#if NET_IF_NUM > 2 +// os_printf("NetBIOS init, name AP: '%s', ST: '%s', Eth: '%s'\n", netbios_name[0], netbios_name[1], netbios_name[2]); + os_printf("NetBIOS init, interface 0: '%s', 1: '%s', 2: '%s'\n", netbios_name[0], netbios_name[1], netbios_name[2]); +#elif NET_IF_NUM > 1 +// os_printf("NetBIOS init, name AP: '%s', ST: '%s'\n", netbios_name[0], netbios_name[1]); + os_printf("NetBIOS init, interface 0: '%s', 1: '%s'\n", netbios_name[0], netbios_name[1]); +#else + os_printf("NetBIOS init\n"); +#endif +#endif + + pcb = udp_new(); + if (pcb != NULL) { + /* we have to be allowed to send broadcast packets! */ + pcb->so_options |= SOF_BROADCAST; + udp_bind(pcb, IP_ADDR_ANY, NETBIOS_PORT); + udp_recv(pcb, netbios_recv, pcb); + } +} +#endif /* LWIP_UDP */ + +#endif // USE_NETBIOS diff --git a/RTL00_SDKV35a/component/common/network/netbios/netbios.h b/RTL00_SDKV35a/component/common/network/netbios/netbios.h new file mode 100644 index 0000000..32566b1 --- /dev/null +++ b/RTL00_SDKV35a/component/common/network/netbios/netbios.h @@ -0,0 +1,29 @@ +#ifndef __NETBIOS_H__ +#define __NETBIOS_H__ + +/** default port number for "NetBIOS Name service */ +#define NETBIOS_PORT 137 + +/** size of a NetBIOS name */ +#define NETBIOS_NAME_LEN 16 + +#ifndef NET_IF_NUM +#define NET_IF_NUM 2 +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +extern char netbios_name[NET_IF_NUM][NETBIOS_NAME_LEN + 1]; // default netifs/interfacenum: 0 - SoftAP, 1 - Station, 2 - Ethernet + +// struct udp_pcb * netbios_pcb(void); +void netbios_init(void); +bool netbios_set_name(unsigned char interfacenum, char * name); // default netifs/interfacenum: 0 - SoftAP, 1 - Station, 2 - Ethernet +bool netbios_off(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __NETBIOS_H__ */ diff --git a/project/inc/rtl8195a/esp_comp.h b/project/inc/rtl8195a/esp_comp.h new file mode 100644 index 0000000..41446c4 --- /dev/null +++ b/project/inc/rtl8195a/esp_comp.h @@ -0,0 +1,114 @@ +/* +* +* +*/ +#ifndef _INCLUDE_ESP_COMP_H_ +#define _INCLUDE_ESP_COMP_H_ + +#include "platform_autoconf.h" + +#define ICACHE_FLASH_ATTR +#define ICACHE_RODATA_ATTR +#define DATA_IRAM_ATTR + +#define os_printf(...) rtl_printf(__VA_ARGS__) +#define os_printf_plus(...) rtl_printf(__VA_ARGS__) +#define os_sprintf_fd(...) rtl_sprintf(__VA_ARGS__) +#define ets_sprintf(...) rtl_sprintf(__VA_ARGS__) +/* +#define os_malloc pvPortMalloc +#define os_zalloc pvPortZalloc +#define os_calloc pvPortCalloc +#define os_realloc pvPortRealloc +*/ +#undef os_free +#define os_free vPortFree +#define system_get_free_heap_size xPortGetFreeHeapSize +#undef os_realloc +#define os_realloc pvPortReAlloc + + +#define os_bzero rtl_bzero +#define os_delay_us wait_us // HalDelayUs +//#define os_install_putc1 rtl_install_putc1 +//#define os_install_putc2 rtl_install_putc2 +//#define os_intr_lock rtl_intr_lock +//#define os_intr_unlock rtl_intr_unlock +//#define os_isr_attach rtl_isr_attach +//#define os_isr_mask rtl_isr_mask +//#define os_isr_unmask rtl_isr_unmask +#define os_memcmp rtl_memcmp +#define os_memcpy rtl_memcpy +#define ets_memcpy rtl_memcpy +#define os_memmove rtl_memmove +#define os_memset rtl_memset +#define os_putc rtl_putc +//#define os_str2macaddr rtl_str2macaddr +//#define os_strcat strcat +#define os_strchr rtl_strchr +#define os_strrchr rtl_strrchr +#define os_strcmp rtl_strcmp +#define os_strcpy rtl_strcpy +#define os_strlen rtl_strlen +#define os_strncmp rtl_strncmp +#define os_strncpy rtl_strncpy +#define os_strstr rtl_strstr +#define os_random Rand +//extern uint32 phy_get_rand(void); +#define system_get_os_print() 1 + +#ifdef USE_US_TIMER +#define os_timer_arm_us(a, b, c) rtl_timer_arm_new(a, b, c) +#endif + + +//#define os_timer_arm(a, b, c) rtl_timer_arm_new(a, b, c) +//#define os_timer_disarm rtl_timer_disarm +//#define os_timer_init rtl_timer_init +//#define os_timer_setfn rtl_timer_setfn + +//#define os_timer_done rtl_timer_done +//#define os_timer_handler_isr rtl_timer_handler_isr + +//#define os_update_cpu_frequency rtl_update_cpu_frequency + +//#define os_sprintf ets_sprintf + +#define spi_flash_real_size() (1<<(flashobj.SpicInitPara.id[2]-1)) + + + +#define ip4_addr1(ipaddr) (((u8_t*)(ipaddr))[0]) +#define ip4_addr2(ipaddr) (((u8_t*)(ipaddr))[1]) +#define ip4_addr3(ipaddr) (((u8_t*)(ipaddr))[2]) +#define ip4_addr4(ipaddr) (((u8_t*)(ipaddr))[3]) +/* These are cast to u16_t, with the intent that they are often arguments + * to printf using the U16_F format from cc.h. */ +#define ip4_addr1_16(ipaddr) ((u16_t)ip4_addr1(ipaddr)) +#define ip4_addr2_16(ipaddr) ((u16_t)ip4_addr2(ipaddr)) +#define ip4_addr3_16(ipaddr) ((u16_t)ip4_addr3(ipaddr)) +#define ip4_addr4_16(ipaddr) ((u16_t)ip4_addr4(ipaddr)) + +#define IP2STR(ipaddr) ip4_addr1_16(ipaddr), \ + ip4_addr2_16(ipaddr), \ + ip4_addr3_16(ipaddr), \ + ip4_addr4_16(ipaddr) + +#define IPSTR "%d.%d.%d.%d" + +/* CONFIG_DEBUG_LOG: +=0 Off all diag/debug msg, +=1 Only errors, +=2 errors + warning, (default) +=3 errors + warning + info, +=4 errors + warning + info + debug, +=5 full */ +#if CONFIG_DEBUG_LOG > 3 +#define DEBUGSOO (CONFIG_DEBUG_LOG - 1) +#elif CONFIG_DEBUG_LOG > 1 +#define DEBUGSOO 2 +#else +#define DEBUGSOO CONFIG_DEBUG_LOG +#endif + +#endif // _INCLUDE_ESP_COMP_H_ diff --git a/project/inc/rtl8195a/os.h b/project/inc/rtl8195a/os.h new file mode 100644 index 0000000..2a0a4a7 --- /dev/null +++ b/project/inc/rtl8195a/os.h @@ -0,0 +1,593 @@ +/* + * OS specific functions + * Copyright (c) 2005-2009, Jouni Malinen + * + * This software may be distributed under the terms of the BSD license. + * See README for more details. + */ + +#ifndef OS_H +#define OS_H + +//#include "basic_types.h" +#include +#include "osdep_service.h" +#include "freertos/wrapper.h" +#include "utils/rom/rom_wps_os.h" + +typedef void* xqueue_handle_t; + +typedef long os_time_t; + +typedef _timer os_timer; + +/** + * os_sleep - Sleep (sec, usec) + * @sec: Number of seconds to sleep + * @usec: Number of microseconds to sleep + */ +void os_sleep(os_time_t sec, os_time_t usec); + +struct os_time { + os_time_t sec; + os_time_t usec; +}; + +struct os_reltime { + os_time_t sec; + os_time_t usec; +}; + +/** + * os_get_time - Get current time (sec, usec) + * @t: Pointer to buffer for the time + * Returns: 0 on success, -1 on failure + */ +int os_get_time(struct os_time *t); + +int os_get_reltime(struct os_reltime *t); +/* Helper macros for handling struct os_time */ +/* (&timeout->time, &tmp->time) */ +#define os_time_before(a, b) \ + ((a)->sec < (b)->sec || \ + ((a)->sec == (b)->sec && (a)->usec < (b)->usec)) + +#define os_time_sub(a, b, res) do { \ + (res)->sec = (a)->sec - (b)->sec; \ + (res)->usec = (a)->usec - (b)->usec; \ + if ((res)->usec < 0) { \ + (res)->sec--; \ + (res)->usec += 1000000; \ + } \ +} while (0) + +/** + * os_mktime - Convert broken-down time into seconds since 1970-01-01 + * @year: Four digit year + * @month: Month (1 .. 12) + * @day: Day of month (1 .. 31) + * @hour: Hour (0 .. 23) + * @min: Minute (0 .. 59) + * @sec: Second (0 .. 60) + * @t: Buffer for returning calendar time representation (seconds since + * 1970-01-01 00:00:00) + * Returns: 0 on success, -1 on failure + * + * Note: The result is in seconds from Epoch, i.e., in UTC, not in local time + * which is used by POSIX mktime(). + */ +int os_mktime(int year, int month, int day, int hour, int min, int sec, + os_time_t *t); + +struct os_tm { + int sec; /* 0..59 or 60 for leap seconds */ + int min; /* 0..59 */ + int hour; /* 0..23 */ + int day; /* 1..31 */ + int month; /* 1..12 */ + int year; /* Four digit year */ +}; + +int os_gmtime(os_time_t t, struct os_tm *tm); + +/* Helpers for handling struct os_time */ + +/* Helpers for handling struct os_reltime */ + +static inline int os_reltime_before(struct os_reltime *a, + struct os_reltime *b) +{ + return os_time_before(a,b); +} + + +static inline void os_reltime_sub(struct os_reltime *a, struct os_reltime *b, + struct os_reltime *res) +{ + os_time_sub(a,b,res); +} + + +static inline void os_reltime_age(struct os_reltime *start, + struct os_reltime *age) +{ + struct os_reltime now; + + os_get_time((struct os_time *)&now); + os_reltime_sub(&now, start, age); +} + + +static inline int os_reltime_expired(struct os_reltime *now, + struct os_reltime *ts, + os_time_t timeout_secs) +{ + struct os_reltime age; + + os_reltime_sub(now, ts, &age); + return (age.sec > timeout_secs) || + (age.sec == timeout_secs && age.usec > 0); +} + +/** + * os_daemonize - Run in the background (detach from the controlling terminal) + * @pid_file: File name to write the process ID to or %NULL to skip this + * Returns: 0 on success, -1 on failure + */ +int os_daemonize(const char *pid_file); + +/** + * os_daemonize_terminate - Stop running in the background (remove pid file) + * @pid_file: File name to write the process ID to or %NULL to skip this + */ +void os_daemonize_terminate(const char *pid_file); + +/** + * os_get_random - Get cryptographically strong pseudo random data + * @buf: Buffer for pseudo random data + * @len: Length of the buffer + * Returns: 0 on success, -1 on failure + */ +int os_get_random(unsigned char *buf, size_t len); + +/** + * os_random - Get pseudo random value (not necessarily very strong) + * Returns: Pseudo random value + */ +unsigned long os_random(void); + +/** + * os_rel2abs_path - Get an absolute path for a file + * @rel_path: Relative path to a file + * Returns: Absolute path for the file or %NULL on failure + * + * This function tries to convert a relative path of a file to an absolute path + * in order for the file to be found even if current working directory has + * changed. The returned value is allocated and caller is responsible for + * freeing it. It is acceptable to just return the same path in an allocated + * buffer, e.g., return strdup(rel_path). This function is only used to find + * configuration files when os_daemonize() may have changed the current working + * directory and relative path would be pointing to a different location. + */ +char * os_rel2abs_path(const char *rel_path); + +/** + * os_program_init - Program initialization (called at start) + * Returns: 0 on success, -1 on failure + * + * This function is called when a programs starts. If there are any OS specific + * processing that is needed, it can be placed here. It is also acceptable to + * just return 0 if not special processing is needed. + */ +int os_program_init(void); + +/** + * os_program_deinit - Program deinitialization (called just before exit) + * + * This function is called just before a program exists. If there are any OS + * specific processing, e.g., freeing resourced allocated in os_program_init(), + * it should be done here. It is also acceptable for this function to do + * nothing. + */ +void os_program_deinit(void); + +/** + * os_setenv - Set environment variable + * @name: Name of the variable + * @value: Value to set to the variable + * @overwrite: Whether existing variable should be overwritten + * Returns: 0 on success, -1 on error + * + * This function is only used for wpa_cli action scripts. OS wrapper does not + * need to implement this if such functionality is not needed. + */ +int os_setenv(const char *name, const char *value, int overwrite); + +/** + * os_unsetenv - Delete environent variable + * @name: Name of the variable + * Returns: 0 on success, -1 on error + * + * This function is only used for wpa_cli action scripts. OS wrapper does not + * need to implement this if such functionality is not needed. + */ +int os_unsetenv(const char *name); + +/** + * os_readfile - Read a file to an allocated memory buffer + * @name: Name of the file to read + * @len: For returning the length of the allocated buffer + * Returns: Pointer to the allocated buffer or %NULL on failure + * + * This function allocates memory and reads the given file to this buffer. Both + * binary and text files can be read with this function. The caller is + * responsible for freeing the returned buffer with os_free(). + */ +char * os_readfile(const char *name, size_t *len); + +//#if 0 +/** + * os_zalloc - Allocate and zero memory + * @size: Number of bytes to allocate + * Returns: Pointer to allocated and zeroed memory or %NULL on failure + * + * Caller is responsible for freeing the returned buffer with os_free(). + */ +void * os_zalloc(size_t size); + +/** + * os_calloc - Allocate and zero memory for an array + * @nmemb: Number of members in the array + * @size: Number of bytes in each member + * Returns: Pointer to allocated and zeroed memory or %NULL on failure + * + * This function can be used as a wrapper for os_zalloc(nmemb * size) when an + * allocation is used for an array. The main benefit over os_zalloc() is in + * having an extra check to catch integer overflows in multiplication. + * + * Caller is responsible for freeing the returned buffer with os_free(). + */ +static inline void * os_calloc(size_t nmemb, size_t size) +{ + if (size && nmemb > (~(size_t) 0) / size) + return NULL; + return os_zalloc(nmemb * size); +} +//#endif + + +static inline int os_memcmp_const(const void *a, const void *b, size_t len) +{ + const u8 *aa = a; + const u8 *bb = b; + size_t i; + u8 res; + + for (res = 0, i = 0; i < len; i++) + res |= aa[i] ^ bb[i]; + + return res; +} + +/* + * The following functions are wrapper for standard ANSI C or POSIX functions. + * By default, they are just defined to use the standard function name and no + * os_*.c implementation is needed for them. This avoids extra function calls + * by allowing the C pre-processor take care of the function name mapping. + * + * If the target system uses a C library that does not provide these functions, + * build_config.h can be used to define the wrappers to use a different + * function name. This can be done on function-by-function basis since the + * defines here are only used if build_config.h does not define the os_* name. + * If needed, os_*.c file can be used to implement the functions that are not + * included in the C library on the target system. Alternatively, + * OS_NO_C_LIB_DEFINES can be defined to skip all defines here in which case + * these functions need to be implemented in os_*.c file for the target system. + */ + +#ifdef OS_NO_C_LIB_DEFINES + +/** + * os_malloc - Allocate dynamic memory + * @size: Size of the buffer to allocate + * Returns: Allocated buffer or %NULL on failure + * + * Caller is responsible for freeing the returned buffer with os_free(). + */ +void * os_malloc(size_t size); + +/** + * os_realloc - Re-allocate dynamic memory + * @ptr: Old buffer from os_malloc() or os_realloc() + * @size: Size of the new buffer + * Returns: Allocated buffer or %NULL on failure + * + * Caller is responsible for freeing the returned buffer with os_free(). + * If re-allocation fails, %NULL is returned and the original buffer (ptr) is + * not freed and caller is still responsible for freeing it. + */ +void * os_realloc(void *ptr, size_t size); + +/** + * os_free - Free dynamic memory + * @ptr: Old buffer from os_malloc() or os_realloc(); can be %NULL + */ +void os_free(void *ptr); + +/** + * os_memcpy - Copy memory area + * @dest: Destination + * @src: Source + * @n: Number of bytes to copy + * Returns: dest + * + * The memory areas src and dst must not overlap. os_memmove() can be used with + * overlapping memory. + */ +void * os_memcpy(void *dest, const void *src, size_t n); + +/** + * os_memmove - Copy memory area + * @dest: Destination + * @src: Source + * @n: Number of bytes to copy + * Returns: dest + * + * The memory areas src and dst may overlap. + */ +void *os_memmove(void *dest, const void *src, size_t n); + +/** + * os_memset - Fill memory with a constant byte + * @s: Memory area to be filled + * @c: Constant byte + * @n: Number of bytes started from s to fill with c + * Returns: s + */ +void *os_memset(void *s, int c, size_t n); + +/** + * os_memcmp - Compare memory areas + * @s1: First buffer + * @s2: Second buffer + * @n: Maximum numbers of octets to compare + * Returns: An integer less than, equal to, or greater than zero if s1 is + * found to be less than, to match, or be greater than s2. Only first n + * characters will be compared. + */ +int os_memcmp(const void *s1, const void *s2, size_t n); + +/** + * os_strdup - Duplicate a string + * @s: Source string + * Returns: Allocated buffer with the string copied into it or %NULL on failure + * + * Caller is responsible for freeing the returned buffer with os_free(). + */ +char *os_strdup(const char *s); + +/** + * os_strlen - Calculate the length of a string + * @s: '\0' terminated string + * Returns: Number of characters in s (not counting the '\0' terminator) + */ +size_t os_strlen(const char *s); + +/** + * os_strcasecmp - Compare two strings ignoring case + * @s1: First string + * @s2: Second string + * Returns: An integer less than, equal to, or greater than zero if s1 is + * found to be less than, to match, or be greatred than s2 + */ +int os_strcasecmp(const char *s1, const char *s2); + +/** + * os_strncasecmp - Compare two strings ignoring case + * @s1: First string + * @s2: Second string + * @n: Maximum numbers of characters to compare + * Returns: An integer less than, equal to, or greater than zero if s1 is + * found to be less than, to match, or be greater than s2. Only first n + * characters will be compared. + */ +int os_strncasecmp(const char *s1, const char *s2, size_t n); + +/** + * os_strchr - Locate the first occurrence of a character in string + * @s: String + * @c: Character to search for + * Returns: Pointer to the matched character or %NULL if not found + */ +char *os_strchr(const char *s, int c); + +/** + * os_strrchr - Locate the last occurrence of a character in string + * @s: String + * @c: Character to search for + * Returns: Pointer to the matched character or %NULL if not found + */ +char *os_strrchr(const char *s, int c); + +/** + * os_strcmp - Compare two strings + * @s1: First string + * @s2: Second string + * Returns: An integer less than, equal to, or greater than zero if s1 is + * found to be less than, to match, or be greatred than s2 + */ +int os_strcmp(const char *s1, const char *s2); + +/** + * os_strncmp - Compare two strings + * @s1: First string + * @s2: Second string + * @n: Maximum numbers of characters to compare + * Returns: An integer less than, equal to, or greater than zero if s1 is + * found to be less than, to match, or be greater than s2. Only first n + * characters will be compared. + */ +int os_strncmp(const char *s1, const char *s2, size_t n); + +/** + * os_strncpy - Copy a string + * @dest: Destination + * @src: Source + * @n: Maximum number of characters to copy + * Returns: dest + */ +char *os_strncpy(char *dest, const char *src, size_t n); + +/** + * os_strstr - Locate a substring + * @haystack: String (haystack) to search from + * @needle: Needle to search from haystack + * Returns: Pointer to the beginning of the substring or %NULL if not found + */ +char *os_strstr(const char *haystack, const char *needle); + +/** + * os_snprintf - Print to a memory buffer + * @str: Memory buffer to print into + * @size: Maximum length of the str buffer + * @format: printf format + * Returns: Number of characters printed (not including trailing '\0'). + * + * If the output buffer is truncated, number of characters which would have + * been written is returned. Since some C libraries return -1 in such a case, + * the caller must be prepared on that value, too, to indicate truncation. + * + * Note: Some C library implementations of snprintf() may not guarantee null + * termination in case the output is truncated. The OS wrapper function of + * os_snprintf() should provide this guarantee, i.e., to null terminate the + * output buffer if a C library version of the function is used and if that + * function does not guarantee null termination. + * + * If the target system does not include snprintf(), see, e.g., + * http://www.ijs.si/software/snprintf/ for an example of a portable + * implementation of snprintf. + */ +int os_snprintf(char *str, size_t size, const char *format, ...); + +#else /* OS_NO_C_LIB_DEFINES */ + +#if !defined(CONFIG_PLATFORM_8195A) && !defined(CONFIG_PLATFORM_8711B) +#ifdef CONFIG_MEM_MONITOR + u8* os_malloc(u32 sz); + void os_mfree(u8 *pbuf, u32 sz); + #ifndef os_free + #define os_free(p, sz) os_mfree(((u8*)(p)), (sz)) + #endif +#else + #ifndef os_malloc + #define os_malloc(sz) _rtw_malloc(sz) + #endif + #ifndef os_free + #define os_free(p, sz) _rtw_mfree(((u8*)(p)), (sz)) + #endif +#endif +#endif + extern void *os_zalloc(size_t size); + extern char *os_strdup(const char *string_copy_from); + + #ifndef os_sleep + #define os_sleep(s, us) rtw_mdelay_os((s)*1000 + (us)/1000) + #endif + #ifndef os_memcpy + #define os_memcpy(d, s, n) rtw_memcpy((void*)(d), ((void*)(s)), (n)) + #endif + #ifndef os_memmove + #define os_memmove(d, s, n) memmove((d), (s), (n)) + #endif + #ifndef os_memset + #define os_memset(pbuf, c, sz) rtw_memset(pbuf, c, sz) + #endif + #ifndef os_memcmp + #define os_memcmp(s1, s2, n) rtw_memcmp(((void*)(s1)), ((void*)(s2)), (n)) + #endif + #ifndef os_memcmp_p2p + #define os_memcmp_p2p(s1, s2, n) memcmp((s1), (s2), (n)) + #endif + #ifndef os_get_random_bytes + #define os_get_random_bytes(d,sz) rtw_get_random_bytes(((void*)(d)), (sz)) + #endif + #ifndef os_strlen + #define os_strlen(s) strlen(s) + #endif + #ifndef os_strcasecmp + #ifdef _MSC_VER + #define os_strcasecmp(s1, s2) _stricmp((s1), (s2)) + #else + #define os_strcasecmp(s1, s2) strcasecmp((s1), (s2)) + #endif + #endif + #ifndef os_strncasecmp + #ifdef _MSC_VER + #define os_strncasecmp(s1, s2, n) _strnicmp((s1), (s2), (n)) + #else + #define os_strncasecmp(s1, s2, n) strncasecmp((s1), (s2), (n)) + #endif + #endif + #ifndef os_init_timer + #define os_init_timer(t, p, f, x, n) rtw_init_timer((t), (p), (f), (x), (n)) + #endif + #ifndef os_set_timer + #define os_set_timer(t, d) rtw_set_timer((t), (d)) + #endif + #ifndef os_cancel_timer + #define os_cancel_timer(t) rtw_cancel_timer(t) + #endif + #ifndef os_del_timer + #define os_del_timer(t) rtw_del_timer(t) + #endif + #ifndef os_atoi + #define os_atoi(s) rtw_atoi(s) + #endif + +#ifndef os_strchr +#define os_strchr(s, c) strchr((s), (c)) +#endif +#ifndef os_strcmp +#define os_strcmp(s1, s2) strcmp((s1), (s2)) +#endif +#ifndef os_strncmp +#define os_strncmp(s1, s2, n) strncmp((s1), (s2), (n)) +#endif +#ifndef os_strncpy +#define os_strncpy(d, s, n) strncpy((d), (s), (n)) +#endif +#ifndef os_strrchr +#define os_strrchr(s, c) strrchr((s), (c)) +#endif +#ifndef os_strstr +#define os_strstr(h, n) strstr((h), (n)) +#endif + +#ifndef os_snprintf + #ifdef _MSC_VER + #define os_snprintf _snprintf + #else + #define os_snprintf snprintf + #endif +#endif + +#endif /* OS_NO_C_LIB_DEFINES */ + + +static inline void * os_realloc_array(void *ptr, size_t nmemb, size_t size) +{ + if (size && nmemb > (~(size_t) 0) / size) + return NULL; + return os_realloc(ptr, nmemb * size, nmemb * size); +} + +void *os_xqueue_create(unsigned long uxQueueLength, unsigned long uxItemSize) ; + +int os_xqueue_receive(xqueue_handle_t xQueue, void * const pvBuffer, unsigned long xSecsToWait); + +void os_xqueue_delete(xqueue_handle_t xQueue ); + +int os_xqueue_send(xqueue_handle_t xQueue, const void * const pvItemToQueue, unsigned long xSecsToWait); + + +#endif /* OS_H */ diff --git a/sdkset.mk b/sdkset.mk index 2930146..58dd726 100644 --- a/sdkset.mk +++ b/sdkset.mk @@ -152,6 +152,7 @@ SRC_C += sdk/component/common/drivers/wlan/realtek/src/osdep/lwip_intf.c SRC_C += sdk/component/common/network/lwip/lwip_v1.4.1/port/realtek/freertos/sys_arch.c SRC_C += sdk/component/common/network/dhcp/dhcps.c SRC_C += sdk/component/common/network/sntp/sntp.c +SRC_C += sdk/component/common/network/netbios/netbios.c #network - mdns SRC_C += sdk/component/common/network/mDNS/mDNSPlatform.c