Ejemplo n.º 1
0
// This cgi uses the routines above to connect to a specific access point with the
// given ESSID using the given password.
int ICACHE_FLASH_ATTR cgiWiFiConnect(HttpdConnData *connData) {
  char essid[128];
  char passwd[128];

  if (connData->conn==NULL) return HTTPD_CGI_DONE;

  int el = httpdFindArg(connData->getArgs, "essid", essid, sizeof(essid));
  int pl = httpdFindArg(connData->getArgs, "passwd", passwd, sizeof(passwd));

  if (el > 0 && pl >= 0) {
    //Set to 0 if you want to disable the actual reconnecting bit
    os_strncpy((char*)stconf.ssid, essid, 32);
    os_strncpy((char*)stconf.password, passwd, 64);
    DBG("Wifi try to connect to AP %s pw %s\n", essid, passwd);

    //Schedule disconnect/connect
    os_timer_disarm(&reassTimer);
    os_timer_setfn(&reassTimer, reassTimerCb, NULL);
    os_timer_arm(&reassTimer, 1000, 0); // 1 second for the response of this request to make it
    jsonHeader(connData, 200);
  } else {
    jsonHeader(connData, 400);
    httpdSend(connData, "Cannot parse ssid or password", -1);
  }
  return HTTPD_CGI_DONE;
}
Ejemplo n.º 2
0
uint8 ICACHE_FLASH_ATTR otb_conf_store_sta_conf(char *ssid, char *password, bool commit)
{
  uint8 rc = OTB_CONF_RC_NOT_CHANGED;
  otb_conf_struct *conf = &otb_conf_private;
  bool update_rc;

  DEBUG("CONF: otb_conf_store_sta_conf entry");
  
  if (os_strncmp(conf->ssid, ssid, OTB_CONF_WIFI_SSID_MAX_LEN) ||
      os_strncmp(conf->password, password, OTB_CONF_WIFI_PASSWORD_MAX_LEN))
  {
    INFO("CONF: New config: ssid, password");
    rc = OTB_CONF_RC_CHANGED;
    os_strncpy(conf->ssid, ssid, OTB_CONF_WIFI_SSID_MAX_LEN);
    os_strncpy(conf->password, password, OTB_CONF_WIFI_PASSWORD_MAX_LEN);
    if (commit)
    {
      INFO("CONF: Committing new config: ssid, password");
      update_rc = otb_conf_update(conf);
      if (!update_rc)
      {
        ERROR("CONF: Failed to update config");
        rc = OTB_CONF_RC_ERROR;
      }
    }
  }
  
  DEBUG("CONF: otb_conf_store_sta_conf exit");
  
  return rc;
}
Ejemplo n.º 3
0
void restoreFactorySettings() {
	wifi_station_disconnect();
	wifi_set_opmode(0x3); //reset to STA+AP mode

	struct softap_config apConfig;
	wifi_softap_get_config(&apConfig);
	os_strncpy((char*)apConfig.ssid, "smartswitch", 18);
	apConfig.authmode = 0; //Disable security
	wifi_softap_set_config(&apConfig);

	struct station_config stconf;
	os_strncpy((char*)stconf.ssid, "", 2);
	os_strncpy((char*)stconf.password, "", 2);
	wifi_station_set_config(&stconf);

	OLED_CLS();
	OLED_Print(2, 0, "RESET", 1);
	os_printf("Reset completed. Restarting system...\n");

	ioOutput(0, GPIO_OUTPUT1);
	ioOutput(0, GPIO_OUTPUT2);

	while (!GPIO_INPUT_GET(GPIO_BUTTON1)) { os_printf("."); };
	while (!GPIO_INPUT_GET(GPIO_BUTTON2)) { os_printf("."); };

	system_restart();
}
Ejemplo n.º 4
0
//This cgi uses the routines above to connect to a specific access point with the
//given ESSID using the given password.
int ICACHE_FLASH_ATTR cgiWiFiConnect(HttpdConnData *connData) {
	char essid[128];
	char passwd[128];
	static ETSTimer reassTimer;
	
	if (connData->conn==NULL) {
		//Connection aborted. Clean up.
		return HTTPD_CGI_DONE;
	}
	
	httpdFindArg(connData->postBuff, "essid", essid, sizeof(essid));
	httpdFindArg(connData->postBuff, "passwd", passwd, sizeof(passwd));

	os_strncpy((char*)stconf.ssid, essid, 32);
	os_strncpy((char*)stconf.password, passwd, 64);

	//Schedule disconnect/connect
	os_timer_disarm(&reassTimer);
	os_timer_setfn(&reassTimer, reassTimerCb, NULL);
#if 0
	os_timer_arm(&reassTimer, 1000, 0);

	httpdRedirect(connData, "connecting.html");
#else
	httpdRedirect(connData, "/wifi");
#endif
	return HTTPD_CGI_DONE;
}
Ejemplo n.º 5
0
//This cgi uses the routines above to connect to a specific access point with the
//given ESSID using the given password.
int ICACHE_FLASH_ATTR cgiWiFiConnect(HttpdConnData *connData) {
	char essid[128];
	char passwd[128];
	static ETSTimer reassTimer;
	
	if (connData->conn==NULL) {
		//Connection aborted. Clean up.
		return HTTPD_CGI_DONE;
	}
	
	httpdFindArg(connData->post->buff, "essid", essid, sizeof(essid));
	httpdFindArg(connData->post->buff, "passwd", passwd, sizeof(passwd));

	os_strncpy((char*)stconf.ssid, essid, 32);
	os_strncpy((char*)stconf.password, passwd, 64);
	os_printf("Try to connect to AP %s pw %s\n", essid, passwd);

	//Schedule disconnect/connect
	os_timer_disarm(&reassTimer);
	os_timer_setfn(&reassTimer, reassTimerCb, NULL);
//Set to 0 if you want to disable the actual reconnecting bit
#ifdef DEMO_MODE
	httpdRedirect(connData, "/wifi");
#else
	os_timer_arm(&reassTimer, 500, 0);
	httpdRedirect(connData, "connecting.html");
#endif
	return HTTPD_CGI_DONE;
}
Ejemplo n.º 6
0
void user_init(void) {
	char * ap = "SKUNKWILLEM";
	char * pass = "******";
	uart_init(BIT_RATE_115200, uart_receive, false);
	system_set_os_print(1);
	os_printf("\nUart init done... \n");


	wifi_softap_get_config(&apconf);
	memset(apconf.ssid, 0, 32);
	memset(apconf.password, 0, 64);

	os_strncpy((char*)apconf.ssid, ap, 32);
	os_strncpy((char*)apconf.password, pass, 64);
	apconf.authmode = AUTH_WPA_WPA2_PSK;
	apconf.max_connection = 5;
	apconf.ssid_hidden = 0;
	wifi_softap_set_config(&apconf);


	IP4_ADDR(&IpInfo.gw, 192, 168, 10, 1);
	IP4_ADDR(&IpInfo.ip, 192, 168, 10, 1);
	IP4_ADDR(&IpInfo.netmask, 255, 255, 255, 0);
	wifi_softap_dhcps_stop();
	dhcps_start(&IpInfo);
	wifi_set_ip_info(0x01, &IpInfo);


	os_timer_disarm(&waitTimer);
	os_timer_setfn(&waitTimer, init_udp, NULL);
	os_timer_arm(&waitTimer, 2000, 0);

}
Ejemplo n.º 7
0
static void * wpa_driver_broadcom_init(void *ctx, const char *ifname)
{
	int s;
	struct sockaddr_ll ll;
	struct wpa_driver_broadcom_data *drv;
	struct ifreq ifr;

	/* open socket to kernel */
	if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
		perror("socket");
		return NULL;
	}
	/* do it */
	os_strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
	if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
		perror(ifr.ifr_name);
		return NULL;
	}


	drv = os_zalloc(sizeof(*drv));
	if (drv == NULL)
		return NULL;
	drv->ctx = ctx;
	os_strncpy(drv->ifname, ifname, sizeof(drv->ifname));
	drv->ioctl_sock = s;

	s = socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2));
	if (s < 0) {
		perror("socket(PF_PACKET, SOCK_RAW, ntohs(ETH_P_802_2))");
		close(drv->ioctl_sock);
		os_free(drv);
		return NULL;
	}

	os_memset(&ll, 0, sizeof(ll));
	ll.sll_family = AF_PACKET;
	ll.sll_protocol = ntohs(ETH_P_802_2);
	ll.sll_ifindex = ifr.ifr_ifindex;
	ll.sll_hatype = 0;
	ll.sll_pkttype = PACKET_HOST;
	ll.sll_halen = 0;

	if (bind(s, (struct sockaddr *) &ll, sizeof(ll)) < 0) {
		perror("bind(netlink)");
		close(s);
		close(drv->ioctl_sock);
		os_free(drv);
		return NULL;
	}

	eloop_register_read_sock(s, wpa_driver_broadcom_event_receive, ctx,
				 NULL);
	drv->event_sock = s;

	return drv;
}
Ejemplo n.º 8
0
// Password authentication for admin interface
int myPassFn(HttpdConnData *connData, int no, char *user, int userLen, char *pass, int passLen)
 {
  if(no==0)
   {
    os_strncpy(user, configGet()->admin_user, userLen);
    os_strncpy(pass, configGet()->admin_pass, passLen);
    return 1;
   }
  return 0;
 }
Ejemplo n.º 9
0
	IROM void Flash::get(char* value, int length, const char* key, const char* dflt) {
		int idx=findKey(key);
		uint16_t len=4;
		if ( idx>=0 ) {
			if ( !loadItem(idx+1,(uint8_t*)value,len) ) {
				os_strncpy(value,dflt,length);
			} else {
				value[len]='\0';
			}
		}
		else os_strncpy(value,dflt,length);
	}
Ejemplo n.º 10
0
bool ICACHE_FLASH_ATTR otb_conf_update_loc(int loc, char *val)
{
  int len;
  bool rc = FALSE;
  otb_conf_struct *conf;

  DEBUG("CONF: otb_conf_update entry");
  
  conf = &otb_conf_private;
  
  OTB_ASSERT((loc >= 1) && (loc <= 3));
  
  len = os_strlen(val);
  if (len > (OTB_CONF_LOCATION_MAX_LEN))
  {
    otb_cmd_rsp_append("location string too long", val);
    goto EXIT_LABEL;
  }
  
  switch (loc)
  {
    case 1:
      os_strncpy(conf->loc.loc1, val, OTB_CONF_LOCATION_MAX_LEN);
      break;
  
    case 2:
      os_strncpy(conf->loc.loc2, val, OTB_CONF_LOCATION_MAX_LEN);
      break;
  
    case 3:
      os_strncpy(conf->loc.loc3, val, OTB_CONF_LOCATION_MAX_LEN);
      break;
  
    default:
      OTB_ASSERT(FALSE);
      goto EXIT_LABEL;
      break;
  }

  rc = otb_conf_update(conf);
  if (!rc)
  {
    ERROR("CONF: Failed to update config");
    otb_cmd_rsp_append("internal error");
  }
  
EXIT_LABEL:

  DEBUG("CONF: otb_conf_update exit");
 
  return rc; 
}
Ejemplo n.º 11
0
/**************************************************************
 * constructor/destructor
 **************************************************************/
v_dataViewQos
u_dataViewQosNew(
    v_dataViewQos tmpl)
{
    v_dataViewQos q;
    u_result result;
    int len;

    q = os_malloc(sizeof(C_STRUCT(v_dataViewQos)));
    if (q != NULL) {
        if (tmpl != NULL) {
            /* Copy non-reference fields */
            *q = *tmpl;
            /* Copy reference fields */
            
            if (tmpl->userKey.enable){
                if (tmpl->userKey.expression != NULL) {
                    len = strlen(tmpl->userKey.expression);
                    q->userKey.expression = os_malloc(len+1);
                    os_strncpy(q->userKey.expression, tmpl->userKey.expression, len);
                    q->userKey.expression[len] = 0;
                } else {
                    q->userKey.expression = NULL;
                }
            }
        } else {
            result = u_dataViewQosInit(q);
            if (result != U_RESULT_OK) {
                u_dataViewQosFree(q);
                q = NULL;
            }
        }
    }
    return q;
}
Ejemplo n.º 12
0
static int broadcom_ioctl(struct wpa_driver_broadcom_data *drv, int cmd,
			  void *buf, int len)
{
	struct ifreq ifr;
	wl_ioctl_t ioc;
	int ret = 0;

	wpa_printf(MSG_MSGDUMP, "BROADCOM: wlioctl(%s,%d,len=%d,val=%p)",
		   drv->ifname, cmd, len, buf);
	/* wpa_hexdump(MSG_MSGDUMP, "BROADCOM: wlioctl buf", buf, len); */

	ioc.cmd = cmd;
	ioc.buf = buf;
	ioc.len = len;
	os_strncpy(ifr.ifr_name, drv->ifname, IFNAMSIZ);
	ifr.ifr_data = (caddr_t) &ioc;
	if ((ret = ioctl(drv->ioctl_sock, SIOCDEVPRIVATE, &ifr)) < 0) {
		if (cmd != WLC_GET_MAGIC)
			perror(ifr.ifr_name);
		wpa_printf(MSG_MSGDUMP, "BROADCOM: wlioctl cmd=%d res=%d",
			   cmd, ret);
	}

	return ret;
}
int wpa_driver_nl80211_driver_cmd(void *priv, char *cmd, char *buf,
				  size_t buf_len )
{
	struct i802_bss *bss = priv;
	struct wpa_driver_nl80211_data *drv = bss->drv;
	struct ifreq ifr;
	android_wifi_priv_cmd priv_cmd;
	int ret = 0;

	if (os_strcasecmp(cmd, "STOP") == 0) {
		linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 0);
		wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STOPPED");
	} else if (os_strcasecmp(cmd, "START") == 0) {
		linux_set_iface_flags(drv->global->ioctl_sock, bss->ifname, 1);
		wpa_msg(drv->ctx, MSG_INFO, WPA_EVENT_DRIVER_STATE "STARTED");
	} else if (os_strcasecmp(cmd, "MACADDR") == 0) {
		u8 macaddr[ETH_ALEN] = {};

		ret = linux_get_ifhwaddr(drv->global->ioctl_sock, bss->ifname, macaddr);
		if (!ret)
			ret = os_snprintf(buf, buf_len,
					  "Macaddr = " MACSTR "\n", MAC2STR(macaddr));
	} else { /* Use private command */
		memset(&ifr, 0, sizeof(ifr));
		memset(&priv_cmd, 0, sizeof(priv_cmd));
		os_memcpy(buf, cmd, strlen(cmd) + 1);
		os_strncpy(ifr.ifr_name, bss->ifname, IFNAMSIZ);

		priv_cmd.buf = buf;
		priv_cmd.used_len = buf_len;
		priv_cmd.total_len = buf_len;
		ifr.ifr_data = &priv_cmd;

		if ((ret = ioctl(drv->global->ioctl_sock, SIOCDEVPRIVATE + 1, &ifr)) < 0) {
			wpa_printf(MSG_ERROR, "%s: failed to issue private commands\n", __func__);
		} else {
			drv_errors = 0;
			ret = 0;
			if ((os_strcasecmp(cmd, "LINKSPEED") == 0) ||
			    (os_strcasecmp(cmd, "RSSI") == 0) ||
			    (os_strcasecmp(cmd, "GETBAND") == 0) )
				ret = strlen(buf);
			else if (os_strcasecmp(cmd, "COUNTRY") == 0)
				wpa_supplicant_event(drv->ctx,
					EVENT_CHANNEL_LIST_CHANGED, NULL);
			else if (os_strncasecmp(cmd, "SETBAND", 7) == 0)
				wpa_printf(MSG_DEBUG, "%s: %s ", __func__, cmd);
			else if (os_strcasecmp(cmd, "P2P_DEV_ADDR") == 0)
				wpa_printf(MSG_DEBUG, "%s: P2P: Device address ("MACSTR")",
					__func__, MAC2STR(buf));
			else if (os_strcasecmp(cmd, "P2P_SET_PS") == 0)
				wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf);
			else if (os_strcasecmp(cmd, "P2P_SET_NOA") == 0)
				wpa_printf(MSG_DEBUG, "%s: P2P: %s ", __func__, buf);
			else
				wpa_printf(MSG_DEBUG, "%s %s len = %d, %d", __func__, buf, ret, strlen(buf));
		}
	}
	return ret;
}
Ejemplo n.º 14
0
c_iter
c_splitString(
    const c_char *str,
    const c_char *delimiters)
{
    const c_char *head, *tail;
    c_char *nibble;
    c_iter iter = NULL;
    c_long length;

    if (str == NULL) return NULL;

    tail = str;
    while (*tail != '\0') {
        head = c_skipUntil(tail,delimiters);
        length = abs((c_address)head - (c_address)tail);
        if (length != 0) {
            length++;
            nibble = (c_string)os_malloc(length);
            os_strncpy(nibble,tail,length);
            nibble[length-1]=0;
            iter = c_iterAppend(iter,nibble);
        }
        tail = head;
        if (c_isOneOf(*tail,delimiters)) tail++;
    }
    return iter;
}
Ejemplo n.º 15
0
v_partitionPolicyI
v_partitionPolicyRemove(
    v_partitionPolicyI p,
    const c_char *expr,
    c_base base)
{
    v_partitionPolicyI newPolicy;
    c_char *str;
    c_char *start; /* start of expr in p */
    os_size_t len;

    newPolicy.v = NULL;
    if (p.v != NULL) {
        if (strcmp(p.v, expr) != 0) {
            len = strlen(p.v);
            str = os_malloc(len + 1);
            start = strstr(p.v, expr);
            assert(start != NULL);
            assert((c_address)start >= (c_address)p.v);
            os_strncpy(str, p.v, (c_address)start - (c_address)p.v); /* includes ',' */
            str[(c_address)start - (c_address)p.v] = 0; /* make '\0' terminated */
            if (strcmp(start, expr) != 0) { /* not at the end */
                os_strcat(str, (c_char *)((c_address)start + strlen(expr) + 1 /* , */));
            }
            newPolicy.v = c_stringNew(base, str);
            os_free(str);
        }
    }

    return newPolicy;
}
Ejemplo n.º 16
0
struct l2_packet_data * l2_packet_init(
	const char *ifname, const u8 *own_addr, unsigned short protocol,
	void (*rx_callback)(void *ctx, const u8 *src_addr,
			    const u8 *buf, size_t len),
	void *rx_callback_ctx, int l2_hdr)
{
	struct l2_packet_data *l2;

	l2 = os_zalloc(sizeof(struct l2_packet_data));
	if (l2 == NULL)
		return NULL;
	os_strncpy(l2->ifname, ifname, sizeof(l2->ifname));
	l2->rx_callback = rx_callback;
	l2->rx_callback_ctx = rx_callback_ctx;
	l2->l2_hdr = l2_hdr;

	if (eth_get(l2->ifname, l2->own_addr) < 0) {
		fprintf(stderr, "Failed to get link-level address for "
			"interface '%s'.\n", l2->ifname);
		os_free(l2);
		return NULL;
	}

	if (l2_packet_init_libpcap(l2, protocol)) {
		os_free(l2);
		return NULL;
	}

	return l2;
}
Ejemplo n.º 17
0
void token_string(char *into, char *json, jsmntok_t t) {
    char tv[100];
    os_strncpy(tv, json+t.start, t.end-t.start);
    tv[t.end-t.start] = 0;
    //print(tv);
    strcpy(into, tv);
}
Ejemplo n.º 18
0
static void * wpa_driver_ipw_init(void *ctx, const char *ifname)
{
    struct wpa_driver_ipw_data *drv;
    int ver;

    wpa_printf(MSG_DEBUG, "%s is called", __FUNCTION__);
    drv = os_zalloc(sizeof(*drv));
    if (drv == NULL)
        return NULL;
    drv->wext = wpa_driver_wext_init(ctx, ifname);
    if (drv->wext == NULL) {
        os_free(drv);
        return NULL;
    }

    ver = wpa_driver_wext_get_version(drv->wext);
    if (ver >= 18) {
        wpa_printf(MSG_WARNING, "Linux wireless extensions version %d "
                   "detected.", ver);
        wpa_printf(MSG_WARNING, "ipw2x00 driver uses driver_wext "
                   "(-Dwext) instead of driver_ipw.");
    }

    drv->ctx = ctx;
    os_strncpy(drv->ifname, ifname, sizeof(drv->ifname));
    drv->sock = socket(PF_INET, SOCK_DGRAM, 0);
    if (drv->sock < 0) {
        wpa_driver_wext_deinit(drv->wext);
        os_free(drv);
        return NULL;
    }

    return drv;
}
Ejemplo n.º 19
0
void ICACHE_FLASH_ATTR syslog_setup(
    char *hostname, int port, const char *app_name, const char **procs, const SYSLOG_MSG *msgs)
{
	char *buffer = NULL;
	int ii;
  sint16 rc;
  syslog_ip_address = (char *)os_zalloc(SYSLOG_IP_LEN);
  buffer = (char *)os_zalloc(SYSLOG_BUF_SIZE * SYSLOG_STACK_DEPTH);
  for (ii = 0; ii < SYSLOG_STACK_DEPTH; ii++)
  {
	  syslog_stack[ii] = buffer;
	  buffer += SYSLOG_BUF_SIZE;
  }

  syslog_conn = (struct espconn *)os_zalloc(sizeof(struct espconn));
  syslog_udp = (esp_udp *)os_zalloc(sizeof(esp_udp));
  syslog_hostname = (char *)os_zalloc(SYSLOG_MAX_HOSTNAME);

  syslog_app_name = app_name;
  syslog_procs = procs;
  syslog_msgs = msgs;
  os_strncpy(syslog_hostname, hostname, SYSLOG_MAX_HOSTNAME);
  os_strcpy(syslog_ip_address, SYSLOG_DUMMY_IP);

  syslog_conn->type = ESPCONN_UDP;
  syslog_conn->proto.udp = syslog_udp;
  syslog_conn->proto.udp->local_port = espconn_port();
  syslog_conn->proto.udp->remote_port = port;
  // // CONSOLE("SYSLOG - setup: %s:%d, rc: %d", hostname, port, rc);
}
Ejemplo n.º 20
0
int ICACHE_FLASH_ATTR cgiMenu(HttpdConnData *connData) {
  if (connData->conn==NULL) return HTTPD_CGI_DONE; // Connection aborted. Clean up.
  char buff[1024];
  // don't use jsonHeader so the response does get cached
  httpdStartResponse(connData, 200);
  httpdHeader(connData, "Cache-Control", "max-age=3600, must-revalidate");
  httpdHeader(connData, "Content-Type", "application/json");
  httpdEndHeaders(connData);
  // limit hostname to 12 chars
  char name[13];
  os_strncpy(name, flashConfig.hostname, 12);
  name[12] = 0;
  // construct json response
  os_sprintf(buff, 
    "{ "
      "\"menu\": [ "
        "\"Overview\", \"/home.html\", "
        "\"WiFi Console\", \"/console.html\", "
        "\"WiFi\", \"/wifi/wifi.html\", "
#ifdef MQTT
        "\"Connectivity\", \"/mqtt.html\", "
#endif
        "\"Debug log\", \"/log.html\""
      " ], "
      "\"version\": \"%s\", "
      "\"name\": \"%s\""
    " }", 
  esp_link_version, name);

  httpdSend(connData, buff, -1);
  return HTTPD_CGI_DONE;
}
Ejemplo n.º 21
0
int l2_packet_get_ip_addr(struct l2_packet_data *l2, char *buf, size_t len)
{
	int s;
	struct ifreq ifr;
	struct sockaddr_in *saddr;

	s = socket(PF_INET, SOCK_DGRAM, 0);
	if (s < 0) {
		perror("socket");
		return -1;
	}
	os_memset(&ifr, 0, sizeof(ifr));
	os_strncpy(ifr.ifr_name, l2->ifname, sizeof(ifr.ifr_name));
	if (ioctl(s, SIOCGIFADDR, &ifr) < 0) {
		if (errno != EADDRNOTAVAIL)
			perror("ioctl[SIOCGIFADDR]");
		close(s);
		return -1;
	}
	close(s);
	saddr = (struct sockaddr_in *) &ifr.ifr_addr;
	if (saddr->sin_family != AF_INET)
		return -1;
	os_snprintf(buf, len, "%s", inet_ntoa(saddr->sin_addr));
	return 0;
}
Ejemplo n.º 22
0
struct l2_packet_data * l2_packet_init(
	const char *ifname, const u8 *own_addr, unsigned short protocol,
	void (*rx_callback)(void *ctx, const u8 *src_addr,
			    const u8 *buf, size_t len),
	void *rx_callback_ctx, int l2_hdr)
{
	struct l2_packet_data *l2;

	l2 = os_zalloc(sizeof(struct l2_packet_data));
	if (l2 == NULL)
		return NULL;
	os_strncpy(l2->ifname, ifname, sizeof(l2->ifname));
	l2->rx_callback = rx_callback;
	l2->rx_callback_ctx = rx_callback_ctx;
	l2->l2_hdr = l2_hdr;

#ifdef CONFIG_WINPCAP
	if (own_addr)
		os_memcpy(l2->own_addr, own_addr, ETH_ALEN);
#else /* CONFIG_WINPCAP */
	if (l2_packet_init_libdnet(l2))
		return NULL;
#endif /* CONFIG_WINPCAP */

	if (l2_packet_init_libpcap(l2, protocol)) {
#ifndef CONFIG_WINPCAP
		eth_close(l2->eth);
#endif /* CONFIG_WINPCAP */
		os_free(l2);
		return NULL;
	}

	return l2;
}
Ejemplo n.º 23
0
void * wpa_driver_awext_init(void *ctx, const char *ifname)
{
	struct wpa_driver_awext_data *drv;
	drv = os_zalloc(sizeof(*drv));
	if (drv == NULL)
		return NULL;
	drv->wext = wpa_driver_wext_init(ctx, ifname);
	if (drv->wext == NULL)
	{
		os_free(drv);
		return NULL;
	}

	drv->ctx = ctx;

	os_strncpy(drv->ifname, ifname, sizeof(drv->ifname));
	drv->ioctl_sock = socket(PF_INET, SOCK_DGRAM, 0);
	if (drv->ioctl_sock < 0)
	{
		wpa_driver_wext_deinit(drv->wext);
		os_free(drv);
		return NULL;
	}

	return drv;
}
Ejemplo n.º 24
0
static int wpa_driver_tista_pmksa(struct wpa_driver_ti_data *drv,
                                  u32 cmd, const u8 *bssid, const u8 *pmkid)
{
    struct iwreq iwr;
    struct iw_pmksa pmksa;
    int ret = 0;

    os_memset(&iwr, 0, sizeof(iwr));
    os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
    os_memset(&pmksa, 0, sizeof(pmksa));
    pmksa.cmd = cmd;
    pmksa.bssid.sa_family = ARPHRD_ETHER;
    if (bssid)
        os_memcpy(pmksa.bssid.sa_data, bssid, ETH_ALEN);
    if (pmkid) {
        os_memcpy(pmksa.pmkid, pmkid, IW_PMKID_LEN);
        wpa_printf(MSG_DEBUG, "pmkid %s", pmkid);
    }
    iwr.u.data.pointer = (caddr_t)&pmksa;
    iwr.u.data.length = sizeof(pmksa);

    if (ioctl(drv->ioctl_sock, SIOCSIWPMKSA, &iwr) < 0) {
        if (errno != EOPNOTSUPP)
            perror("ioctl[SIOCSIWPMKSA]");
        ret = -1;
    }
    return ret;
}
Ejemplo n.º 25
0
static int
wpa_driver_madwifi_scan(void *priv, const u8 *ssid, size_t ssid_len)
{
	struct wpa_driver_madwifi_data *drv = priv;
	struct iwreq iwr;
	int ret = 0;

	os_memset(&iwr, 0, sizeof(iwr));
	os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);

	/* set desired ssid before scan */
	/* FIX: scan should not break the current association, so using
	 * set_ssid may not be the best way of doing this.. */
	if (wpa_driver_wext_set_ssid(drv->wext, ssid, ssid_len) < 0)
		ret = -1;

	if (ioctl(drv->sock, SIOCSIWSCAN, &iwr) < 0) {
		perror("ioctl[SIOCSIWSCAN]");
		ret = -1;
	}

	/*
	 * madwifi delivers a scan complete event so no need to poll, but
	 * register a backup timeout anyway to make sure that we recover even
	 * if the driver does not send this event for any reason. This timeout
	 * will only be used if the event is not delivered (event handler will
	 * cancel the timeout).
	 */
	eloop_register_timeout(30, 0, wpa_driver_wext_scan_timeout, drv->wext,
			       drv->ctx);

	return ret;
}
Ejemplo n.º 26
0
void* _os_malloc(const int8 *aFileName, int32 aLineNo, IN int32 aSize)
{
	void *ptr = malloc(aSize);
#ifdef  MEM_TRACE
	MallocPtrLinkedList *mallocPtrLinkedList = NULL;
	MallocStruct *mallocStruct = (MallocStruct*)malloc(sizeof(MallocStruct));
	if(NULL == mallocStruct){
		goto _os_malloc;
	}
	if(os_strlen((int8*)aFileName)){
		os_strncpy(mallocStruct->FileName,aFileName,sizeof(mallocStruct->FileName));
	}
	mallocStruct->LineNo = aLineNo;
	mallocStruct->Size = aSize;
	mallocStruct->Ptr = ptr;

	mallocPtrLinkedList = (MallocPtrLinkedList*)malloc(sizeof(MallocPtrLinkedList));
	if(NULL == mallocPtrLinkedList){
		free(mallocStruct);
		goto _os_malloc;
	}
	mallocPtrLinkedList->mallocStruct = mallocStruct;
	mallocPtrLinkedList->NextPtr = NULL;
	if(gMallocPtrLinkedListStartPtr == NULL){
		gMallocPtrLinkedListStartPtr = gMallocPtrLinkedListLastPtr = mallocPtrLinkedList;
	}else{
		gMallocPtrLinkedListLastPtr->NextPtr = mallocPtrLinkedList;
		gMallocPtrLinkedListLastPtr = mallocPtrLinkedList;
	}
_os_malloc:
#endif
	return ptr;
}
Ejemplo n.º 27
0
void initslave(){
	char * ap = CLIENT_AP;
	char * pass = MASTER_PASSWORD;
	wifi_set_opmode(STATION_MODE);
	wifi_softap_get_config(&apconf);
	os_strncpy((char*)apconf.ssid, ap, 32);
	os_strncpy((char*)apconf.password, pass, 64);
	apconf.authmode = AUTH_WPA_WPA2_PSK;
	apconf.max_connection = 20;
	apconf.ssid_hidden = 0;
	wifi_softap_set_config(&apconf);
	scan_slave();
	reg_addlistener(callback_slave, 0x32);

	os_timer_setfn(&watchdog_slave, (os_timer_func_t *)slave_sendalive, NULL);
	os_timer_arm(&watchdog_slave, 2000, 0);
}
Ejemplo n.º 28
0
static int wpa_driver_awext_open_mlme(struct wpa_driver_awext_data *drv)
{
	int flags, ifindex, s, *i;
	struct sockaddr_ll addr;
	struct iwreq iwr;

	os_memset(&iwr, 0, sizeof(iwr));
	os_strncpy(iwr.ifr_name, drv->ifname, IFNAMSIZ);
	i = (int *) iwr.u.name;
	*i++ = PRISM2_PARAM_USER_SPACE_MLME;
	*i++ = 1;

	if (ioctl(drv->ioctl_sock, PRISM2_IOCTL_PRISM2_PARAM, &iwr) < 0) {
		wpa_printf(MSG_ERROR, "WEXT: Failed to configure driver to "
			   "use user space MLME");
		return -1;
	}

	ifindex = if_nametoindex(drv->wext->mlmedev);
	if (ifindex == 0) {
		wpa_printf(MSG_ERROR, "WEXT: mlmedev='%s' not found",
			   drv->mlmedev);
		return -1;
	}

	if (wpa_driver_awext_get_ifflags_ifname(drv, drv->wext->mlmedev, &flags) != 0
	    || wpa_driver_awext_set_ifflags_ifname(drv, drv->wext->mlmedev,
						  flags | IFF_UP) != 0) {
		wpa_printf(MSG_ERROR, "WEXT: Could not set interface "
			   "'%s' UP", drv->mlmedev);
		return -1;
	}

	s = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
	if (s < 0) {
		perror("socket[PF_PACKET,SOCK_RAW]");
		return -1;
	}

	os_memset(&addr, 0, sizeof(addr));
	addr.sll_family = AF_PACKET;
	addr.sll_ifindex = ifindex;

	if (bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
		perror("bind(MLME)");
		return -1;
	}

	if (eloop_register_read_sock(s, wpa_driver_awext_mlme_read, drv, NULL))
	{
		wpa_printf(MSG_ERROR, "WEXT: Could not register MLME read "
			   "socket");
		close(s);
		return -1;
	}

	return s;
}
Ejemplo n.º 29
0
static void
wrapd_wireless_event_wireless(struct wrap_demon *aptr, struct ifinfomsg *ifi,
				                        char *data, int len)
{
    struct iw_event iwe_buf, *iwe = &iwe_buf;
    char *pos, *end, *custom;
    char parent[IFNAMSIZ] = {0};
    char child[IFNAMSIZ] = {0};    
    u_int32_t flags = WRAPD_PSTA_FLAG_OPEN;  
    int i;

    wrapd_ifindex_to_ifname(aptr, ifi->ifi_index, child);
    for (i = 0; i < HOSTAPD_CNT; i ++) {
        if ((wrapd_hostapd_conn[i]) && (os_strcmp(child, ap_ifname[i]) == 0))
            return;
    }
    
    pos = data;
    end = data + len;

    while (pos + IW_EV_LCP_LEN <= end) { //+4
        os_memcpy(&iwe_buf, pos, IW_EV_LCP_LEN);
        if (iwe->len <= IW_EV_LCP_LEN)
            return;

        custom = pos + IW_EV_POINT_LEN;
        if (iwe->cmd == IWEVEXPIRED || iwe->cmd == IWEVREGISTERED ){
            os_memcpy(&iwe_buf, pos, sizeof(struct iw_event));
            custom += IW_EV_POINT_OFF;
        }



        switch (iwe->cmd) {
        case IWEVEXPIRED:
            wrapd_psta_remove(aptr,(u8 *) iwe->u.addr.sa_data);               
            break;
            
        case IWEVREGISTERED:
            if (dbdc_ifname) {
                os_strncpy(parent, dbdc_ifname, IFNAMSIZ);
                parent[IFNAMSIZ - 1] = '\0';
                flags &= ~WRAPD_PSTA_FLAG_MAT;
            } else {
                wrapd_ifindex_to_parent_ifname(aptr, ifi->ifi_index, parent);
                flags |= WRAPD_PSTA_FLAG_MAT;
            }
            wrapd_psta_add(aptr, parent, child, (u8 *)(iwe->u.addr.sa_data), flags);           
            break;
            
        case IWEVASSOCREQIE:            
        case IWEVCUSTOM: 
			break;
        }

        pos += iwe->len;
    }
}
Ejemplo n.º 30
0
// Perform a TCP command: parse the command and do the right thing.
// Returns true on success.
bool ICACHE_FLASH_ATTR
tcpClientCommand(uint8_t chan, char cmd, char *cmdBuf) {
	TcpConn *tci;
	char *hostname;
	char *port;

	// copy the command so we can modify it
	char buf[128];
	os_strncpy(buf, cmdBuf, 128);
	buf[127] = 0;

	switch (cmd) {
	//== TCP Connect command
	case 'T':
		hostname = buf;
		port = hostname;
		while (*port != 0 && *port != ':') port++;
		if (*port != ':') break;
		*port = 0;
		port++;
		int portInt = atoi(port);
		if (portInt < 1 || portInt > 65535) break;

		// allocate a connection
		tci = tcpConnAlloc(chan);
		if (tci == NULL) break;
		tci->state = TCP_dns;
		tci->tcp->remote_port = portInt;

		// start the DNS resolution
		os_printf("TCP %p resolving %s for chan %d (conn=%p)\n", tci, hostname, chan ,tci->conn);
		ip_addr_t ip;
		err_t err = espconn_gethostbyname(tci->conn, hostname, &ip, tcpClientHostnameCb);
		if (err == ESPCONN_OK) {
			// dns cache hit, got the IP address, fake the callback (sigh)
			os_printf("TCP DNS hit\n");
			tcpClientHostnameCb(hostname, &ip, tci->conn);
		} else if (err != ESPCONN_INPROGRESS) {
			tcpConnFree(tci);
			break;
		}

		return true;

	//== TCP Close/disconnect command
	case 'C':
		os_printf("TCP closing chan %d\n", chan);
		tci = tcpConn+chan;
		if (tci->state > TCP_idle) {
			tci->state = TCP_idle; // hackish...
			espconn_disconnect(tci->conn);
		}
		break;

	}
	return false;
}