Beispiel #1
0
//Template code for the led page.
void ICACHE_FLASH_ATTR tplLed(HttpdConnData *connData, char *token, void **arg) {
	char buff[128];
	if (token==NULL) return;

	os_strcpy(buff, "Unknown");
	if (os_strcmp(token, "ledstate")==0) {
		if (currLedState) {
			os_strcpy(buff, "on");
		} else {
			os_strcpy(buff, "off");
		}
	}
	espconn_sent(connData->conn, (uint8 *)buff, os_strlen(buff));
}
Beispiel #2
0
/*	cgiReadFlash	*/
int ICACHE_FLASH_ATTR cgiReadFlash(HttpdConnection *	ptConnection)
{
	/* initialization */
	int 	iRet 			= 0;
	int *	iFlashOffset 	= NULL;

	iFlashOffset = (int *)&ptConnection->pbCgiData;

	if (NULL == ptConnection->ptEspConnection)
	{
		/* connection aborted - clean up */
		iRet = HTTPD_CGI_DONE;
		goto lblCleanup;
	}

	if (0 == *iFlashOffset)
	{

#ifdef CGIFLASH_DEBUG
		os_printf("cgiReadFlash: begin flash download\n");
#endif

		httpdStartResponse(ptConnection, 200);
		httpdHeader(ptConnection, "Content-Type", "application/bin");
		httpdEndHeaders(ptConnection);

		/* update offset */
		*iFlashOffset = 0x40200000;

		iRet = HTTPD_CGI_MORE;
		goto lblCleanup;
	}
	
	/* send 1K of flash per call, will be called again if haven't sent 512K yet */
	espconn_sent(ptConnection->ptEspConnection, (uint8 *)(*iFlashOffset), 1024);
	*iFlashOffset += 1024;
	if (*iFlashOffset >= 0x40200000 + (512 * 1024))
	{
		iRet = HTTPD_CGI_DONE;
		goto lblCleanup;
	}
	else
	{
		iRet = HTTPD_CGI_MORE;
		goto lblCleanup;
	}

lblCleanup:
	return iRet;
}
Beispiel #3
0
/**
 * @brief  Send out top message in queue onto socket
 */
static void ICACHE_FLASH_ATTR
mqtt_send_message(MQTT_Client* client) {
  //DBG_MQTT("MQTT: Send_message\n");
  PktBuf *buf = client->msgQueue;
  if (buf == NULL || client->sending) return; // ahem...
  client->msgQueue = PktBuf_Shift(client->msgQueue);

  // get some details about the message
  uint16_t msg_type = mqtt_get_type(buf->data);
  uint8_t  msg_id = mqtt_get_id(buf->data, buf->filled);
  msg_id = msg_id;
#ifdef MQTT_DBG
  os_printf("MQTT: Send type=%s id=%04X len=%d\n", mqtt_msg_type[msg_type], msg_id, buf->filled);
#if 0
  for (int i=0; i<buf->filled; i++) {
    if (buf->data[i] >= ' ' && buf->data[i] <= '~') os_printf("%c", buf->data[i]);
    else os_printf("\\x%02X", buf->data[i]);
  }
  os_printf("\n");
#endif
#endif

  // send the message out
  if (client->security)
    espconn_secure_sent(client->pCon, buf->data, buf->filled);
  else
    espconn_sent(client->pCon, buf->data, buf->filled);
  client->sending = true;

  // depending on whether it needs an ack we need to hold on to the message
  bool needsAck =
    (msg_type == MQTT_MSG_TYPE_PUBLISH && mqtt_get_qos(buf->data) > 0) ||
    msg_type == MQTT_MSG_TYPE_PUBREL || msg_type == MQTT_MSG_TYPE_PUBREC ||
    msg_type == MQTT_MSG_TYPE_SUBSCRIBE || msg_type == MQTT_MSG_TYPE_UNSUBSCRIBE ||
    msg_type == MQTT_MSG_TYPE_PINGREQ;
  if (msg_type == MQTT_MSG_TYPE_PINGREQ) {
    client->pending_buffer = NULL; // we don't need to rexmit this one
    client->sending_buffer = buf;
  } else if (needsAck) {
    client->pending_buffer = buf;  // remeber for rexmit on disconnect/reconnect
    client->sending_buffer = NULL;
    client->timeoutTick = client->sendTimeout+1; // +1 to ensure full sendTireout seconds
  } else {
    client->pending_buffer = NULL;
    client->sending_buffer = buf;
    client->timeoutTick = 0;
  }
  client->keepAliveTick = client->connect_info.keepalive > 0 ? client->connect_info.keepalive+1 : 0;
}
Beispiel #4
0
//Template code for the Tcp server status
void ICACHE_FLASH_ATTR tplTcpServerStatus(HttpdConnData *connData, char *token, void **arg) {
	char buff[512];
	static struct station_config stconf;
	if (token==NULL) return;
	wifi_station_get_config(&stconf);
	os_strcpy(buff, "Unknown");
	if (os_strcmp(token, "WiFiSettings")==0) {
		os_printf("-%s-%s Getting ip settings to replace token: %s \r\n", __FILE__, __func__, token);		
		char ipSettings[256] = { 0};
		GetTcpServerStatus(ipSettings);
		os_strcpy(buff, ipSettings);
		os_printf("-%s-%s Found ip settings: %s \r\n", __FILE__, __func__, buff);		
	}
	espconn_sent(connData->conn, (uint8 *)buff, os_strlen(buff));
}
Beispiel #5
0
/******************************************************************************
 * FunctionName : upgrade_connect
 * Description  : client connected with a host successfully
 * Parameters   : arg -- Additional argument to pass to the callback function
 * Returns      : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
upgrade_connect_cb(void *arg){
    struct espconn *pespconn = arg;

    UPGRADE_DBG("upgrade_connect_cb\n");
    os_timer_disarm(&upgrade_connect_timer);

    espconn_regist_disconcb(pespconn, upgrade_disconcb);
    espconn_regist_sentcb(pespconn, upgrade_datasent);

    if (pbuf != NULL) {
        UPGRADE_DBG("%s\n", pbuf);
        espconn_sent(pespconn, pbuf, os_strlen(pbuf));
    }
}
Beispiel #6
0
// method socket.send(bytes)
STATIC mp_obj_t esp_socket_send(mp_obj_t self_in, mp_obj_t buf_in) {
    esp_socket_obj_t *s = self_in;

    if (s->espconn->state == ESPCONN_NONE || s->espconn->state == ESPCONN_CLOSE) {
        nlr_raise(mp_obj_new_exception_msg(&mp_type_OSError,
            "not connected"));
    }

    mp_buffer_info_t bufinfo;
    mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);

    espconn_sent(s->espconn, bufinfo.buf, bufinfo.len);

    return mp_obj_new_int(bufinfo.len);
}
Beispiel #7
0
// Send the next buffer (assumes that the connection is in a state that allows it)
static void ICACHE_FLASH_ATTR
tcpDoSend(TcpConn *tci) {
	sint8 err = espconn_sent(tci->conn, (uint8*)tci->txBuf, tci->txBufLen);
	if (err == ESPCONN_OK) {
		// send successful
		os_printf("TCP sent (%p %p)\n", tci->conn, tci);
		tci->txBuf[tci->txBufLen] = 0; os_printf("TCP data: %s\n", tci->txBuf);
		tci->txBufSent = tci->txBuf;
		tci->txBuf = NULL;
		tci->txBufLen = 0;
	} else {
		// send error, leave as-is and try again later...
		os_printf("TCP send err (%p %p) %d\n", tci->conn, tci, err);
	}
}
Beispiel #8
0
void ICACHE_FLASH_ATTR ssSentCb(void *arg) {
    struct espconn *pespconn = (struct espconn *)arg;
    struct HttpConnection *c = getHttpConnection(pespconn); 

    if (c->r.complete == 1) {
        espconn_disconnect(pespconn);
        return;
    }
    
    ureq_run(&c->r);
    espconn_sent(pespconn, c->r.response.data, c->r.len);
    if (c->r.len < 1024) {
        espconn_disconnect(pespconn);
    }

}
Beispiel #9
0
static void ICACHE_FLASH_ATTR replyOK(struct espconn *conn) {
	char bfr[2048];
	int l;
	l = os_sprintf(bfr, "HTTP/1.0 %d OK\r\nServer: esp8266-http/0.4\r\nConnection: close\r\n\r\n", 200);
	l += os_sprintf(&bfr[l], "<html><body>");
	l += os_sprintf(&bfr[l], "<h3>MQTT Setup</h3><form action=\"/setup\">");
	l += os_sprintf(&bfr[l], "<p>MQTT host: <input type=\"text\" name=\"MQTThost\" value=\"%s\"></p>", sysCfg.mqtt_host);
	l += os_sprintf(&bfr[l], "<p>MQTT Port: <input type=\"text\" name=\"MQTTport\" value=\"%d\" size=\"4\"></p>", sysCfg.mqtt_port);
	l += os_sprintf(&bfr[l], "<p>MQTT UserID: <input type=\"text\" name=\"MQTTuser\" value=\"%s\"></p>", sysCfg.mqtt_user);
	l += os_sprintf(&bfr[l], "<p>MQTT Pwd: <input type=\"text\" name=\"MQTTpass\" value=\"%s\"></p>", sysCfg.mqtt_pass);
	l += os_sprintf(&bfr[l], "<p>Device ID prefix: <input type=\"text\" name=\"DevPrefix\" value=\"%s\"></p>", sysCfg.deviceID_prefix);
	l += os_sprintf(&bfr[l], "Reboot: <input type=\"checkbox\" name=\"reboot\" value=\"yes\" %s> ", reboot ? "checked" : "");
	l += os_sprintf(&bfr[l], "<input type=\"submit\" name=\"Action\" value=\"Update\" style=\"border-radius: 8px; background-color: #CAD0E6\">");
	l += os_sprintf(&bfr[l], "</form></body></html>");
	espconn_sent(conn, bfr, l);
}
Beispiel #10
0
static void ICACHE_FLASH_ATTR
tcpclient_sent_cb(void *arg) {
  struct espconn *pCon = (struct espconn *)arg;
  RestClient* client = (RestClient *)pCon->reverse;
  DBG("REST: Sent\n");
  if (client->data_sent != client->data_len) {
    // we only sent part of the buffer, send the rest
    espconn_sent(client->pCon, (uint8_t*)(client->data+client->data_sent),
          client->data_len-client->data_sent);
    client->data_sent = client->data_len;
  } else {
    // we're done sending, free the memory
    if (client->data) os_free(client->data);
    client->data = 0;
  }
}
Beispiel #11
0
static void ICACHE_FLASH_ATTR sent_callback(void * arg)
{
	struct espconn * conn = (struct espconn *)arg;
	request_args * req = (request_args *)conn->reverse;

	if (req->post_data == NULL) {
		PRINTF("All sent\n");
	}
	else {
		// The headers were sent, now send the contents.
		PRINTF("Sending request body\n");
		espconn_sent(conn, (uint8_t *)req->post_data, strlen(req->post_data));
		os_free(req->post_data);
		req->post_data = NULL;
	}
}
Beispiel #12
0
void ESP_RestClient::_send() {
	String data;
	switch (m_commandType) {
	case GET:
		data += "GET ";
		break;
	case PUT:
		data += "PUT ";
		break;
	case POST:
		data += "POST ";
		break;
	}
	// Build the start line of the request.
	data += String(m_path) + String(" HTTP/1.1\r\n");

	// Add the headers to the HTTP request
	int size = m_headers.size();
	for (int i = 0; i < size; i++) {
		Header *pHeader = (Header *) m_headers.get(i);
		data += pHeader->getName() + String(": ") + pHeader->getValue()
				+ String("\r\n");
	}

	// Add the payload length if the type is PUT or POST.
	if (m_commandType == PUT || m_commandType == POST) {
		data += "Content-Length: " + String(strlen(m_payload)) + String("\r\n");
	}
	// Add the data separator line.
	data += String("\r\n");

	// Add the payload if we have any.
	if (m_payload != NULL) {
		data += m_payload;
	}

	// Send the buffer.
	int length = data.length() + 1;
	m_pSendBuffer = (uint8_t *) malloc(length);
	data.getBytes(m_pSendBuffer, length, 0);
	int rc = espconn_sent(&m_conn, m_pSendBuffer, length);
	if (rc != 0) {
		// Error
		LOG("Error with send: %d\n", rc);
		return;
	}
} // End of _send
//This is a catch-all cgi function. It takes the url passed to it, looks up the corresponding
//path in the filesystem and if it exists, passes the file through. This simulates what a normal
//webserver would do with static files.
int ICACHE_FLASH_ATTR cgiEspFsHook(HttpdConnData *connData) {
	EspFsFile *file=connData->cgiData;
	int len;
	char buff[1024];
#ifdef GZIP_COMPRESSION
	const char *gzipSendResult = NULL;
#endif
	
	if (connData->conn==NULL) {
		//Connection aborted. Clean up.
		espFsClose(file);
		return HTTPD_CGI_DONE;
	}

	if (file==NULL) {
		//First call to this cgi. Open the file so we can read it.
		file=espFsOpen(connData->url);
		if (file==NULL) {
			return HTTPD_CGI_NOTFOUND;
		}
		connData->cgiData=file;
		httpdStartResponse(connData, 200);
		httpdHeader(connData, "Content-Type", httpdGetMimetype(connData->url));
#ifdef GZIP_COMPRESSION
		gzipSendResult = sendGZIPEncodingIfNeeded(connData);
		if (gzipSendResult != NULL) {
			httpdEndHeaders(connData);
			httpdSend(connData, gzipSendResult, os_strlen(gzipSendResult));
			return HTTPD_CGI_DONE;
		}
#endif
		httpdHeader(connData, "Cache-Control", "max-age=3600, must-revalidate");
		httpdEndHeaders(connData);
		return HTTPD_CGI_MORE;
	}

	len=espFsRead(file, buff, 1024);
	if (len>0) espconn_sent(connData->conn, (uint8 *)buff, len);
	if (len!=1024) {
		//We're done.
		espFsClose(file);
		return HTTPD_CGI_DONE;
	} else {
		//Ok, till next time.
		return HTTPD_CGI_MORE;
	}
}
Beispiel #14
0
static void server_serve(struct espconn *c, void *p, unsigned short len) {
  int res;
  char *buf = NULL;
  char *filename;
  const char *ok = "HTTP/1.1 200 OK\r\n\r\n";
  const char *ok_gzip = "HTTP/1.1 200 OK\r\nContent-Encoding: gzip\n\r\n";
  const char *resp = ok;
  const char not_found[] = "HTTP/1.1 404 Not Found\r\n\r\n";
  const char server_error[] = "HTTP/1.1 500 Internal error\r\n\r\n";
  spiffs_stat stat;
  spiffs_file fd = 0;

  (void) p;
  (void) len;

  if (len >= 16 && strncmp(p, "GET /favicon.ico", 16) == 0) {
    espconn_sent(c, (char *) not_found, sizeof(not_found));
    return;
  } else {
    filename = "index.html";
  }

  if ((res = SPIFFS_stat(&fs, filename, &stat)) < 0) {
    espconn_sent(c, (char *) server_error, sizeof(server_error));
    return;
  }

  if ((fd = SPIFFS_open(&fs, filename, SPIFFS_RDONLY, 0)) < 0) {
    espconn_sent(c, (char *) server_error, sizeof(server_error));
    return;
  }

  int resp_size = strlen(resp) + stat.size;
  buf = malloc(resp_size + 1);
  if (buf == NULL) {
    espconn_sent(c, (char *) server_error, sizeof(server_error));
    goto cleanup;
  }

  memcpy(buf, resp, strlen(resp));

  if ((res = SPIFFS_read(&fs, fd, buf + strlen(resp), stat.size)) < 0) {
    espconn_sent(c, (char *) server_error, sizeof(server_error));
    goto cleanup;
  }

  buf[resp_size] = '\0';
  espconn_sent(c, (char *) buf, resp_size);

cleanup:
  if (buf) free(buf);
  SPIFFS_close(&fs, fd);
  return;
}
void procfn_ledtest_req(struct espconn* pconn, char* pdata, unsigned short len)
{
	os_printf("Enter %s, pconn: [%p], buf: [%p], len:[%d]\n", __func__, pconn, pdata, len);
	uint8 buf[2];
    led_glint* led = (led_glint*)os_zalloc(sizeof(led_glint));

	PIN_FUNC_SELECT(PERIPHS_IO_MUX_MTDI_U, FUNC_GPIO12);
	led->pin = BIT12;
    led->interval = 100;
    led->limit_count = 100;
    led_glint_control(led);

	buf[0] = sizeof(buf);
	buf[1] = LEDTEST_RSP;

	espconn_sent(pconn, buf, 2);
}
void procfn_rst_req(struct espconn* pconn, char* pdata, unsigned short len)
{
	os_printf("Enter %s, pconn: [%p], buf: [%p], len:[%d]\n", __func__, pconn, pdata, len);
	uint8 buf[2];

	buf[0] = sizeof(buf);
	buf[1] = RST_RSP;

	espconn_sent(pconn, buf, 2);
	espconn_disconnect(pconn);

	//直接调用restart总是故障,改用定时器,100毫秒后重启,顺带也可以把网络数据发出去
	ETSTimer* ptimer = (ETSTimer*)os_zalloc(sizeof(ETSTimer));
	os_timer_disarm(ptimer);
	os_timer_setfn(ptimer, restart_timer_cb, ptimer);
	os_timer_arm(ptimer, 100, 0);
}
Beispiel #17
0
void ICACHE_FLASH_ATTR
tcpclient_connect_cb(void *arg)
{
	struct espconn *pCon = (struct espconn *)arg;
	REST_CLIENT* client = (REST_CLIENT *)pCon->reverse;

	espconn_regist_disconcb(client->pCon, tcpclient_discon_cb);
	espconn_regist_recvcb(client->pCon, tcpclient_recv);////////
	espconn_regist_sentcb(client->pCon, tcpclient_sent_cb);///////

	if(client->security){
		espconn_secure_sent(client->pCon, client->data, client->data_len);
	}
	else{
		espconn_sent(client->pCon, client->data, client->data_len);
	}
}
Beispiel #18
0
void httpd_set_error_state(struct HttpdConnectionSlot *slot, uint16_t code, char *codemessage, char *message) {
	char strTemp[32];
	uint16_t messagelen=strlen(message);
	slot->bufferLen = 0;
	httpd_add_buffer_string(slot,"HTTP/1.0 ");
	os_sprintf(strTemp,"%d ",code);
	httpd_add_buffer_string(slot,strTemp);
	httpd_add_buffer_string(slot,codemessage);
	httpd_add_buffer_string(slot,"\r\nContent-Length: ");
	os_sprintf(strTemp,"%d ",messagelen);
	httpd_add_buffer_string(slot,strTemp);
	httpd_add_buffer_string(slot,"\r\nContent-Type: text/plain\r\n\r\n");
	httpd_add_buffer_string(slot,message);

	slot->state = HTTPD_STATE_RESPONDING;
	espconn_sent(slot->conn, slot->buffer, slot->bufferLen);
}
Beispiel #19
0
static void ICACHE_FLASH_ATTR
at_tcpclient_connect_cb(void *arg)
{
	struct espconn *pespconn = (struct espconn *)arg;
	#ifdef PLATFORM_DEBUG
	ets_uart_printf("TCP client connect\r\n");
	#endif
	espconn_regist_sentcb(pespconn, at_tcpclient_sent_cb);
	//espconn_regist_recvcb(pespconn, at_tcpclient_recv);
	espconn_regist_disconcb(pespconn, at_tcpclient_discon_cb);
	char payload[128];
	os_sprintf(payload, MACSTR ",%s\r\n", MAC2STR(macaddr), "ESP8266");
	#ifdef PLATFORM_DEBUG
	ets_uart_printf(payload);
	#endif
	espconn_sent(pespconn, payload, strlen(payload));
}
Beispiel #20
0
void ICACHE_FLASH_ATTR
MQTT_Task(os_event_t *e)
{
	MQTT_Client* client = (MQTT_Client*)e->par;
	uint8_t dataBuffer[MQTT_BUF_SIZE];
	uint16_t dataLen;
	if(e->par == 0)
		return;
	switch(client->connState){

	case TCP_RECONNECT_REQ:
		break;
	case TCP_RECONNECT:
		MQTT_Connect(client);
		INFO("TCP: Reconnect to: %s:%d\r\n", client->host, client->port);
		client->connState = TCP_CONNECTING;
		break;
	case MQTT_DATA:
		if(QUEUE_IsEmpty(&client->msgQueue) || client->sendTimeout != 0) {
			break;
		}
		if(QUEUE_Gets(&client->msgQueue, dataBuffer, &dataLen, MQTT_BUF_SIZE) == 0){
			client->mqtt_state.pending_msg_type = mqtt_get_type(dataBuffer);
			client->mqtt_state.pending_msg_id = mqtt_get_id(dataBuffer, dataLen);


			client->sendTimeout = MQTT_SEND_TIMOUT;
			INFO("MQTT: Sending, type: %d, id: %04X\r\n",client->mqtt_state.pending_msg_type, client->mqtt_state.pending_msg_id);
			if(client->security){
				espconn_secure_sent(client->pCon, dataBuffer, dataLen);
			}
			else{
				espconn_sent(client->pCon, dataBuffer, dataLen);
			}

			client->mqtt_state.outbound_message = NULL;
			break;
		}
		break;
	case TCP_CONNECTING_ERROR:
		MQTT_Disconnect(client);
		MQTT_exit(client);
		break;
	}
}
Beispiel #21
0
LOCAL void ICACHE_FLASH_ATTR clientConnectedCallback(void *arg)
{
  struct espconn *pespconn = arg;
  connState = TCP_CONNECTED;

  espconn_regist_sentcb(pespconn, clientSentCallback);
  espconn_regist_recvcb(pespconn, clientReceiveCallback);

  sint8 sentStatus = espconn_sent(pespconn, txPayload, os_strlen(txPayload));
  if (sentStatus == ESPCONN_OK) {
    connState = TCP_SENDING;
    ets_uart_printf("TCP connected, sending request: %s\r\n", txPayload);
  } else {
    connState = TCP_SEND_ERROR;
    ets_uart_printf("ERROR: TCP send failed, disconnecting ...\r\n");
    espconn_disconnect(pespconn);
  }
}
Beispiel #22
0
static void ICACHE_FLASH_ATTR
tcpclient_connect_cb(void *arg) {
  struct espconn *pCon = (struct espconn *)arg;
  RestClient* client = (RestClient *)pCon->reverse;
  DBG("REST #%d: connected\n", client-restClient);
  espconn_regist_disconcb(client->pCon, tcpclient_discon_cb);
  espconn_regist_recvcb(client->pCon, tcpclient_recv);
  espconn_regist_sentcb(client->pCon, tcpclient_sent_cb);

  client->data_sent = client->data_len <= 1400 ? client->data_len : 1400;
  DBG("REST #%d: sending %d\n", client-restClient, client->data_sent);
  //if(client->security){
  //  espconn_secure_sent(client->pCon, client->data, client->data_sent);
  //}
  //else{
    espconn_sent(client->pCon, (uint8_t*)client->data, client->data_sent);
  //}
}
Beispiel #23
0
/***
 * Send data if in Idle state
 */
static void ICACHE_FLASH_ATTR
my_sent_next() {

	if (my_send_state == Idle && !fifo_is_empty(msg_queue)) {

		my_send_state = WaitingForSend;
		my_send_queue_item_t *i = (my_send_queue_item_t *) fifo_first(msg_queue);

		// when the connection is closed do not send the data
		if (i->l->free) {
			remove_first();
			my_sent_next();
		} else {
			espconn_sent(i->l->pCon, i->data, i->length);
		}
	}

}
Beispiel #24
0
void ICACHE_FLASH_ATTR mqtt_timer(void *arg)
{
	MQTT_Client* client = (MQTT_Client*)arg;

	if(client->connState == MQTT_DATA){
		client->keepAliveTick ++;
		if(client->keepAliveTick > client->mqtt_state.connect_info->keepalive){

			INFO("\r\nMQTT: Send keepalive packet to %s:%d!\r\n", client->host, client->port);
			client->mqtt_state.outbound_message = mqtt_msg_pingreq(&client->mqtt_state.mqtt_connection);
			client->mqtt_state.pending_msg_type = MQTT_MSG_TYPE_PINGREQ;
			client->mqtt_state.pending_msg_type = mqtt_get_type(client->mqtt_state.outbound_message->data);
			client->mqtt_state.pending_msg_id = mqtt_get_id(client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length);


			client->sendTimeout = MQTT_SEND_TIMOUT;
			INFO("MQTT: Sending, type: %d, id: %04X\r\n",client->mqtt_state.pending_msg_type, client->mqtt_state.pending_msg_id);
			if(client->security){
				espconn_secure_sent(client->pCon, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length);
			}
			else{
				espconn_sent(client->pCon, client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length);
			}

			client->mqtt_state.outbound_message = NULL;

			client->keepAliveTick = 0;
			system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
		}

	} else if(client->connState == TCP_RECONNECT_REQ){
		client->reconnectTick ++;
		if(client->reconnectTick > MQTT_RECONNECT_TIMEOUT) {
			client->reconnectTick = 0;
			client->connState = TCP_RECONNECT;
			system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
		}
	}else if(client->connState == TCP_CONNECTING){
		client->connState = TCP_CONNECTING_ERROR;
		system_os_post(MQTT_TASK_PRIO, 0, (os_param_t)client);
	}
	if(client->sendTimeout > 0)
		client->sendTimeout --;
}
Beispiel #25
0
//Cgi that reads the SPI flash. Assumes 512KByte flash.
int ICACHE_FLASH_ATTR cgiReadFlash(HttpdConnData *connData) {
	int *pos=(int *)&connData->cgiData;
	if (connData->conn==NULL) {
		//Connection aborted. Clean up.
		return HTTPD_CGI_DONE;
	}

	if (*pos==0) {
		//os_printf("Start flash download.\n");
		httpdStartResponse(connData, 200);
		httpdHeader(connData, "Content-Type", "application/bin");
		httpdEndHeaders(connData);
		*pos=0x40200000;
		return HTTPD_CGI_MORE;
	}
	espconn_sent(connData->conn, (uint8 *)(*pos), 1024);
	*pos+=1024;
	if (*pos>=0x40200000+(512*1024)) return HTTPD_CGI_DONE; else return HTTPD_CGI_MORE;
}
Beispiel #26
0
// ----------------------------------------------------------------------------
// Callback Function.
// When you call the function wifi_station_scan() below, the ESP8266 goes off
// and starts scanning. When it is done, this function is called automatically.
// ----------------------------------------------------------------------------
void ICACHE_FLASH_ATTR wifiSendCb(void *arg, STATUS status)
{
    char payload[1024], *ptr;
    int n, noAps;
    struct bss_info *bss_link = (struct bss_info *)arg;

    os_printf("wifi scan send done %d\n", status);
    if(status != OK) {
        scanInProgress = 0;   // clear scanning in progress flag
        return;
    }
    noAps = 0;                         // variable for count of AP's found
    while(bss_link != NULL) {          // Count amount of access points found.
        bss_link = bss_link->next.stqe_next;
        noAps++;
    }
    os_printf("Scan done: found %d AP's, sending...\n", noAps);

    ptr = payload;
    os_sprintf(ptr,">APs_found:%d,", noAps); ptr = &payload[strlen(payload)];
    os_sprintf(ptr,"BSSID;SSID;RSSI;Auth,"); ptr = &payload[strlen(payload)];;
    n = 0;
    bss_link = (struct bss_info *)arg;
    while(bss_link != NULL) {
        if(n >= noAps) {
            os_printf("Warning: I have more than the allocated %d aps!\n", noAps);
            break;
        }
        if(bss_link->rssi != 0) {
           os_sprintf(ptr,"%02X:%02X:%02X:%02X:%02X:%02X;",bss_link->bssid[0],bss_link->bssid[1],bss_link->bssid[2],bss_link->bssid[3],bss_link->bssid[4],bss_link->bssid[5]);
           ptr = payload + strlen(payload);
           os_sprintf(ptr,"%s;%d;%x,", (char*)bss_link->ssid, bss_link->rssi,  bss_link->authmode);
           ptr = payload + strlen(payload);
        }
        bss_link = bss_link->next.stqe_next;  // linked list, step to next link
        n++;
    }
    scanInProgress = 0;                 // clear scanning in progress flag
    os_sprintf(ptr,"AP_list_end,\n");

    os_printf("UDP sending list...\n");
    espconn_sent(&Conn, (uint8 *)payload, os_strlen(payload));
}
Beispiel #27
0
/**
  * @brief  Get version connection version
  * @param  arg: contain the ip link information
  * @retval None
  */
void ICACHE_FLASH_ATTR
get_version_connect_cb(void *arg)
{
  struct espconn *pespconn = (struct espconn *)arg;
  fota_client_t *fota_client = (fota_client_t *)pespconn->reverse;

  espconn_regist_recvcb(pespconn, get_version_recv);
  espconn_regist_sentcb(pespconn, get_version_sent_cb);

  uint8_t user_bin[12] = {0};
  if(system_upgrade_userbin_check() == UPGRADE_FW_BIN1) {
    os_memcpy(user_bin, "image2", os_strlen("image2"));
  }
  else if(system_upgrade_userbin_check() == UPGRADE_FW_BIN2) {
    os_memcpy(user_bin, "image1", os_strlen("image1"));
  }

  char *temp = NULL;
  temp = (uint8 *) os_zalloc(512);

  os_sprintf(temp, "GET /api/%s/versions/%s HTTP/1.0\r\nHost: %s\r\n"pHeadStatic""pHeadAuthen"\r\n",
    PROJECT,
    user_bin,
    fota_client->host,
    // fota_client->uuid,   //pHeaderAuthen
    fota_client->token
    // FOTA_CLIENT
    // VERSION
    );

  // INFO("request: %s\n", temp);

  if (FOTA_SECURE)
    espconn_secure_sent(pespconn, temp, os_strlen(temp));
  else
    espconn_sent(pespconn, temp, os_strlen(temp));

  FREE(temp);

  // prepare to get response
  get_version_body_len = -1;
}
Beispiel #28
0
LOCAL void yeelinkget(void) {
//    struct espconn ptrespconn;
//	LOCAL esp_tcp esptcp;
	static u8_t i = 0;
	static u16_t length;
//	static char buf[8]={"led"};
	char str_tmp[128] = {0};
	char remote_server[] = "api.yeelink.net";
	static char apikey[] = "fa93b17ce5d3b8bfae0988b503d0b4fa";
	static char http_request[DATA_BUF_SIZE] = {0};	//声明为静态变量,防止堆栈溢出
//http://api.yeelink.net/v1.0/device/20857/sensor/36576/datapoints

	os_sprintf(str_tmp, "/v1.1/device/20857/sensor/36576/datapoints");
	os_sprintf(http_request , "POST %s HTTP/1.1\r\n", str_tmp);
	os_sprintf(str_tmp , "Host:%s\r\n" , remote_server);
	os_strcat(http_request , str_tmp);
	os_strcat(http_request , "Accept: */*\r\n");
	os_sprintf(str_tmp , "U-ApiKey:%s\r\n" , apikey); //需要替换为自己的APIKey
	os_strcat(http_request , str_tmp);
	os_strcat(http_request , "Content-Length: 12\r\n");
	os_strcat(http_request , "Content-Type: application/x-www-form-urlencoded\r\n");
	os_strcat(http_request , "Connection: close\r\n");
	os_strcat(http_request , "\r\n");

	os_strcat(http_request , "{\"value\":31}");

	length = os_strlen(http_request);
	os_printf("%s", http_request);
	espconn_regist_recvcb(&esp_conn, webserver_recv);
//	espconn_regist_sentcb(&esp_conn, sentcb);
	espconn_connect(&esp_conn);
	if (0 == espconn_sent(&esp_conn, http_request, length)) {
		os_printf("sent ok\n");
	}

	if ((i++) & 0x01) {
		GPIO_OUTPUT_SET(GPIO_ID_PIN(0), LED_ON);
	} else {
		GPIO_OUTPUT_SET(GPIO_ID_PIN(0), LED_OFF);
	}

}
Beispiel #29
0
int ICACHE_FLASH_ATTR authBasic(HttpdConnData *connData) {
	const char *forbidden="401 Forbidden.";
	int no=0;
	int r;
	char hdr[(AUTH_MAX_USER_LEN+AUTH_MAX_PASS_LEN+2)*10];
	char userpass[AUTH_MAX_USER_LEN+AUTH_MAX_PASS_LEN+2];
	char user[AUTH_MAX_USER_LEN];
	char pass[AUTH_MAX_PASS_LEN];
	if (connData->conn==NULL) {
		//Connection aborted. Clean up.
		return HTTPD_CGI_DONE;
	}

	r=httpdGetHeader(connData, "Authorization", hdr, sizeof(hdr));
	if (r && strncmp(hdr, "Basic", 5)==0) {
		r=base64_decode(strlen(hdr)-6, hdr+6, sizeof(userpass), (unsigned char *)userpass);
		if (r<0) r=0; //just clean out string on decode error
		userpass[r]=0; //zero-terminate user:pass string
//		os_printf("Auth: %s\n", userpass);
		while (((AuthGetUserPw)(connData->cgiArg))(connData, no,
				user, AUTH_MAX_USER_LEN, pass, AUTH_MAX_PASS_LEN)) {
			//Check user/pass against auth header
			if (strlen(userpass)==strlen(user)+strlen(pass)+1 &&
					os_strncmp(userpass, user, strlen(user))==0 &&
					userpass[strlen(user)]==':' &&
					os_strcmp(userpass+strlen(user)+1, pass)==0) {
				//Authenticated. Yay!
				return HTTPD_CGI_AUTHENTICATED;
			}
			no++; //Not authenticated with this user/pass. Check next user/pass combo.
		}
	}

	//Not authenticated. Go bug user with login screen.
	httpdStartResponse(connData, 401);
	httpdHeader(connData, "Content-Type", "text/plain");
	httpdHeader(connData, "WWW-Authenticate", "Basic realm=\""HTTP_AUTH_REALM"\"");
	httpdEndHeaders(connData);
	espconn_sent(connData->conn, (uint8 *)forbidden, os_strlen(forbidden));
	//Okay, all done.
	return HTTPD_CGI_DONE;
}
Beispiel #30
0
/******************************************************************************
 * FunctionName : upgrade_connect
 * Description  : client connected with a host successfully
 * Parameters   : arg -- Additional argument to pass to the callback function
 * Returns      : none
*******************************************************************************/
LOCAL void ICACHE_FLASH_ATTR
upgrade_connect_cb(void *arg)
{
    struct espconn *pespconn = arg;

    UPGRADE_DBG("upgrade_connect_cb\n");
    os_timer_disarm(&upgrade_10s);

    espconn_regist_disconcb(pespconn, upgrade_disconcb);
    espconn_regist_sentcb(pespconn, upgrade_datasent);

    if (pbuf != NULL) {
        UPGRADE_DBG(pbuf);
#ifdef UPGRADE_SSL_ENABLE
        espconn_secure_sent(pespconn, pbuf, os_strlen(pbuf));
#else
        espconn_sent(pespconn, pbuf, os_strlen(pbuf));
#endif
    }
}