static struct pico_device *pico_pcap_create(char *if_file_name, char *name, uint8_t *mac, int mode)
{
struct pico_device_pcap *pcap = PICO_ZALLOC(sizeof(struct pico_device_pcap));
char errbuf[2000];
if (!pcap)
return NULL;
if( 0 != pico_device_init((struct pico_device *)pcap, name, mac)) {
dbg ("Pcap init failed.\n");
pico_pcap_destroy((struct pico_device *)pcap);
return NULL;
}
pcap->dev.overhead = 0;
if (mode == PICO_PCAP_MODE_LIVE)
pcap->conn = pcap_open_live(if_file_name, 2000, 100, 10, errbuf);
else
pcap->conn = pcap_open_offline(if_file_name, errbuf);
if (!pcap->conn) {
pico_pcap_destroy((struct pico_device *)pcap);
return NULL;
}
pcap->dev.send = pico_pcap_send;
pcap->dev.poll = pico_pcap_poll;
pcap->dev.destroy = pico_pcap_destroy;
dbg("Device %s created.\n", pcap->dev.name);
return (struct pico_device *)pcap;
}
struct pico_device *
pico_netmap_create(char *interface, char *name, uint8_t *mac) {
struct pico_device_netmap *netmap;
char ifname[IFNAMSIZ + 7];
netmap = PICO_ZALLOC(sizeof(struct pico_device_netmap));
if (!netmap) {
return NULL;
}
if (pico_device_init((struct pico_device *)netmap, name, mac)) {
pico_netmap_destroy((struct pico_device *)netmap);
return NULL;
}
sprintf(ifname, "netmap:%s", interface);
netmap->dev.overhead = 0;
netmap->conn = nm_open(ifname, NULL, 0, 0);
if (! netmap->conn) {
pico_netmap_destroy((struct pico_device *)netmap);
return NULL;
}
netmap->dev.send = pico_netmap_send;
netmap->dev.poll = pico_netmap_poll;
netmap->dev.destroy = pico_netmap_destroy;
return (struct pico_device *) netmap;
}
struct pico_device *pico_ipc_create(const char *sock_path, const char *name, const uint8_t *mac)
{
struct pico_device_ipc *ipc = PICO_ZALLOC(sizeof(struct pico_device_ipc));
if (!ipc)
return NULL;
ipc->dev.mtu = IPC_MTU;
if( 0 != pico_device_init((struct pico_device *)ipc, name, mac)) {
dbg("Ipc init failed.\n");
pico_ipc_destroy((struct pico_device *)ipc);
return NULL;
}
ipc->dev.overhead = 0;
ipc->fd = ipc_connect(sock_path);
if (ipc->fd < 0) {
dbg("Ipc creation failed.\n");
pico_ipc_destroy((struct pico_device *)ipc);
return NULL;
}
ipc->dev.send = pico_ipc_send;
ipc->dev.poll = pico_ipc_poll;
ipc->dev.destroy = pico_ipc_destroy;
dbg("Device %s created.\n", ipc->dev.name);
return (struct pico_device *)ipc;
}
struct pico_device *pico_vde_create(char *sock, char *name, uint8_t *mac)
{
struct pico_device_vde *vde = PICO_ZALLOC(sizeof(struct pico_device_vde));
struct vde_open_args open_args = {
.mode = 0700
};
char vdename[] = "picotcp";
if (!vde)
return NULL;
if( 0 != pico_device_init((struct pico_device *)vde, name, mac)) {
dbg ("Vde init failed.\n");
pico_vde_destroy((struct pico_device *)vde);
return NULL;
}
vde->dev.overhead = 0;
vde->sock = PICO_ZALLOC(strlen(sock) + 1);
memcpy(vde->sock, sock, strlen(sock));
vde->conn = vde_open(sock, vdename, &open_args);
if (!vde->conn) {
pico_vde_destroy((struct pico_device *)vde);
return NULL;
}
vde->dev.send = pico_vde_send;
vde->dev.poll = pico_vde_poll;
vde->dev.destroy = pico_vde_destroy;
//printf("Device %s created.\n", vde->dev.name);
return (struct pico_device *)vde;
}
struct pico_device *pico_tun_create(char *name)
{
struct pico_device_tun *tun = PICO_ZALLOC(sizeof(struct pico_device_tun));
if (!tun)
return NULL;
if( 0 != pico_device_init((struct pico_device *)tun, name, NULL)) {
dbg("Tun init failed.\n");
pico_tun_destroy((struct pico_device *)tun);
return NULL;
}
tun->dev.overhead = 0;
tun->fd = tun_open(name);
if (tun->fd < 0) {
dbg("Tun creation failed.\n");
pico_tun_destroy((struct pico_device *)tun);
return NULL;
}
tun->dev.send = pico_tun_send;
tun->dev.poll = pico_tun_poll;
tun->dev.destroy = pico_tun_destroy;
dbg("Device %s created.\n", tun->dev.name);
return (struct pico_device *)tun;
}
int main()
{
uint8_t mac[6];
uint32_t timer = 0;
/* Obtain the ethernet MAC address */
eth_mac(mac);
const char *ipaddr="192.168.0.150";
uint16_t port_be = 0;
interrupt_register(irq_timer, GUEST_TIMER_INT);
/* Configure the virtual ethernet driver */
struct pico_device* eth_dev = PICO_ZALLOC(sizeof(struct pico_device));
if(!eth_dev) {
return 0;
}
eth_dev->send = eth_send;
eth_dev->poll = eth_poll;
eth_dev->link_state = eth_link_state;
if( 0 != pico_device_init((struct pico_device *)eth_dev, "virt-eth", mac)) {
printf ("\nDevice init failed.");
PICO_FREE(eth_dev);
return 0;
}
/* picoTCP initialization */
printf("\nInitializing pico stack\n");
pico_stack_init();
wolfSSL_Debugging_ON();
pico_string_to_ipv4(ipaddr, &my_eth_addr.addr);
pico_string_to_ipv4("255.255.255.0", &netmask.addr);
pico_ipv4_link_add(eth_dev, my_eth_addr, netmask);
port_be = short_be(LISTENING_PORT);
/* WolfSSL initialization only, to make sure libwolfssl.a is needed */
pico_https_setCertificate(cert_pem_2048, sizeof(cert_pem_2048));
pico_https_setPrivateKey(privkey_pem_2048, sizeof(privkey_pem_2048));
pico_https_server_start(0, serverWakeup);
while (1){
eth_watchdog(&timer, 500);
/* pooling picoTCP stack */
pico_stack_tick();
}
return 0;
}
struct pico_device * pico_eth_create(char *name, uint8_t *mac)
{
struct pico_device * mrf24wg = PICO_ZALLOC(sizeof(struct pico_device));
if (!mrf24wg)
return NULL;
/* SPI CS, RESET INTERRUPT */
printf("mrf24w> init\n");
mrf24w_init(SPI2, GPIOB, GPIO_PIN_12, GPIOB, GPIO_PIN_10, GPIOB, GPIO_PIN_11);
wf_init();
mrf24wg->poll = pico_mrf24_poll;
mrf24wg->send = pico_mrf24_send;
/* Get MAC address */
wf_getMacAddress(mac);
printf("mrf24w> mac: %x:%x:%x:%x:%x:%x\n", mac[0],mac[1],mac[2],mac[3],mac[4],mac[5]);
if(0 != pico_device_init(mrf24wg, name, mac)) {
dbg("mrf24w> init failed.\r\n");
return NULL;
}
/* start with a scan */
{
uint8_t connectionProfileId;
uint8_t channelList[] = {};
//connectionProfileId = wf_cpCreate();
//ASSERT(connectionProfileId != 0xff);
//wf_cpSetSsid(connectionProfileId, (uint8_t*) m_ssid, strlen(m_ssid));
//wf_cpSetNetworkType(connectionProfileId, m_wirelessMode);
//wf_caSetScanType(WF_ACTIVE_SCAN);
//wf_caSetChannelList(channelList, sizeof (channelList));
//wf_caSetListRetryCount(10);
//wf_caSetBeaconTimeout(40);
//wf_cpSetSecurity(connectionProfileId, m_securityType, 0, m_securityPassphrase, m_securityPassphraseLen);
//wf_cmConnect(connectionProfileId);
wf_scan(0xFF); // Scan using default filter
}
return mrf24wg;
}
struct mock_device *pico_mock_create(uint8_t*mac)
{
struct mock_device*mock = PICO_ZALLOC(sizeof(struct mock_device));
if(!mock)
return NULL;
mock->dev = PICO_ZALLOC(sizeof(struct pico_device));
if (!mock->dev) {
PICO_FREE(mock);
return NULL;
}
if(mac != NULL) {
mock->mac = PICO_ZALLOC(6 * sizeof(uint8_t));
if(!mock->mac) {
PICO_FREE(mock->mac);
PICO_FREE(mock);
return NULL;
}
memcpy(mock->mac, mac, 6);
}
if( 0 != pico_device_init((struct pico_device *)mock->dev, "mock", mac)) {
dbg ("Loop init failed.\n");
pico_mock_destroy((struct pico_device *)mock->dev);
if(mock->mac != NULL)
PICO_FREE(mock->mac);
PICO_FREE(mock);
return NULL;
}
mock->dev->send = pico_mock_send;
mock->dev->poll = pico_mock_poll;
mock->dev->destroy = pico_mock_destroy;
dbg("Device %s created.\n", mock->dev->name);
pico_tree_insert(&mock_device_tree, mock);
return mock;
}
