BST_IP_ERR_T BST_IP_BsdSocket( BST_FD_T *pfd, BST_ARG_T *Arg, BST_UINT16 usProtocol )
{
    BST_UINT32                          ulTimeout;
    ulTimeout                           = BST_IP_RX_TIME_OUT;
    if( BST_NULL_PTR == pfd )
    {
        return BST_IP_ERR_ARG;
    }
    switch( usProtocol )
    {
        case BST_IP_PROTOCOL_UDP:
            pfd->lFd                    = lwip_socket( AF_INET, SOCK_DGRAM, 0 );
            break;
        case BST_IP_PROTOCOL_TCP:
            pfd->lFd                    = lwip_socket( AF_INET, SOCK_STREAM, 0 );    //TCP对应SOCK_STREAM
            break;
        default :
            pfd->lFd                    = BST_IP_ERR_MEM;
            return BST_IP_ERR_ARG;
    }

    if( BST_IP_IsBsdFdValid( (*pfd) ) )
    {
        if ( 0 == lwip_setsockopt( pfd->lFd, SOL_SOCKET, SO_RCVTIMEO, &ulTimeout, BST_OS_SIZEOF( ulTimeout ) ) )
        {
            return BST_IP_ERR_OK;
        }

        return BST_IP_ERR_VAL;
    }
    else
    {
        return BST_IP_ERR_MEM;
    }
}
Пример #2
0
int32_t trcSocketInitializeListener()
{
  if (sock >= 0)
	return 0;
  
  sock = lwip_socket(AF_INET, SOCK_STREAM, 0);

  if (sock < 0)
    return -1;

  address.sin_family = AF_INET;
  address.sin_port = htons( TRC_TCPIP_PORT );
  address.sin_addr.s_addr = INADDR_ANY;

  if (bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0)
  {
    closesocket(sock);
    sock = -1;
    return -1;
  }

  if (lwip_listen(sock, 5) < 0)
  {
    closesocket(sock);
    sock = -1;
    return -1;
  }

  return 0;
}
Пример #3
0
void echo_application_thread()
{
	int sock, new_sd;
	struct sockaddr_in address, remote;
	int size;

	if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)
		return;

	address.sin_family = AF_INET;
	address.sin_port = htons(echo_port);
	address.sin_addr.s_addr = INADDR_ANY;

	if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0)
		return;

	lwip_listen(sock, 0);

	size = sizeof(remote);

	while (1) {
		if ((new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t *)&size)) > 0) {
			sys_thread_new("echos", process_echo_request,
				(void*)new_sd,
				THREAD_STACKSIZE,
				DEFAULT_THREAD_PRIO);
		}
	}
}
Пример #4
0
void telnet_init(int vdefd)
{
	int sockfd;
	struct sockaddr_in  serv_addr;
	vdehist_termread=lwip_read;
	vdehist_termwrite=lwip_write;
	vdehist_logincmd=telnet_logincmd;
	sockfd=lwip_socket(AF_INET, SOCK_STREAM, 0);

	if (!sockfd) {
		printlog(LOG_ERR,"telnet socket err: %s",strerror(errno));
	}

	bzero((char *) &serv_addr, sizeof(serv_addr));
	serv_addr.sin_family      = AF_INET;
	serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
	serv_addr.sin_port        = htons(TELNET_TCP_PORT);

	if (lwip_bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
		printlog(LOG_ERR,"telnet bind err: %s",strerror(errno));
	}

	lwip_listen(sockfd, 5);

	addpfd(sockfd,telnetaccept);
}
Пример #5
0
static void
ping_thread(void *arg)
{
  int s;
  int timeout = PING_RCV_TIMEO;
  ip_addr_t ping_target;

  LWIP_UNUSED_ARG(arg);

  if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
    return;
  }

  lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

  while (1) {
    ping_target = PING_TARGET;

    if (ping_send(s, &ping_target) == ERR_OK) {
      LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
      ip_addr_debug_print(PING_DEBUG, &ping_target);
      LWIP_DEBUGF( PING_DEBUG, ("\n"));

      ping_time = sys_now();
      ping_recv(s);
    } else {
      LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
      ip_addr_debug_print(PING_DEBUG, &ping_target);
      LWIP_DEBUGF( PING_DEBUG, (" - error\n"));
    }
    sys_msleep(PING_DELAY);
  }
}
Пример #6
0
static void
mc_event_thread_call_local(mc_event_thread_callback_f callback, void *closure, uint32_t flags)
{
	int s;
	struct sockaddr_in sin;
	mc_local_event_t ev;
	int fl;

	if ((s = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
		return;
	fl = lwip_fcntl(s, F_GETFL, 0);
	lwip_fcntl(s, F_SETFL, fl | O_NONBLOCK);
	sin.sin_family = AF_INET;
	sin.sin_port = htons(MC_LOCAL_EVENT_PORT);
	sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	ev.callback = callback;
	ev.closure = closure;
	ev.flags = flags;
#if USE_SEMAPHORE
	mc_task_init(&ev);
#endif
	lwip_sendto(s, &ev, sizeof(ev), 0, (struct sockaddr *)&sin, sizeof(sin));
#if !USE_SEMAPHORE
	if (!(flags & MC_CALL_ASYNC))
		lwip_recv(s, &ev, sizeof(ev), 0);
#endif
	lwip_close(s);
#if USE_SEMAPHORE
	if (!(flags & MC_CALL_ASYNC)) {
		mc_task_sleep(&ev);
		mc_task_fin(&ev);
	}
#endif
}
Пример #7
0
/*
 * Function: CreateUdpSocket
 * Description: Create a socket to an UDP port
 * Return: Handle to the socket
 */
int CreateUdpSocket(uint16_t port, UdpCbkFunc cbkFunc)
{
	int udpSocket;
	struct sockaddr_in sLocalAddr;
	imask_t val;

	  /* Init socket */
	udpSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0);

	Irq_Save(val);
	for(int i=0;i<MAX_NUM_OF_SOCKETS;i++){
		if(sockList[i] == (-1)){
			sockList[i] = udpSocket;
			cbkFuncList[i] = cbkFunc;
			break;
		}
	}
	Irq_Restore(val);

	memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));

	/*Source*/
	sLocalAddr.sin_family = AF_INET;
	sLocalAddr.sin_len = sizeof(sLocalAddr);
	sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
	sLocalAddr.sin_port = htons(port);

	if(lwip_bind(udpSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) < 0)
	{
		KillUdpSocket(udpSocket);
	}

	return udpSocket;
}
Пример #8
0
int
main(int argc, char **argv)
{
      int sock, length;
      struct sockaddr_in server;
      int msgsock;
      int i;
	// intalization 
	lwip_tcpip_init();
	/* DHCP */
	//enum { BUF_SIZE = Nic::Packet_allocator::DEFAULT_PACKET_SIZE * 128 };
 	int  BUF_SIZE= 200000;
	if (lwip_nic_init(0, 0, 0, BUF_SIZE, BUF_SIZE)) {
		printf("ERROR: We got no IP address!\n");
		return 1;
	}

      /* Create socket */
      sock = lwip_socket(AF_INET, SOCK_STREAM, 0);
      if (sock < 0) {
            perror("opening stream socket");
            exit(1);
      }

      /* Name socket using wildcards */
      server.sin_family = AF_INET;
      server.sin_addr.s_addr = INADDR_ANY;
      server.sin_port = htons(SRV_PORT);
      if (lwip_bind(sock, (struct sockaddr *)&server, sizeof(server))) {
            perror("binding stream socket");
            exit(1);
      }

      /* Find out assigned port number and print it out */
      //length = sizeof(server);
      //if (getsockname(sock, (struct sockaddr *)&server, &length)) {
      //      perror("getting socket name");
      //      exit(1);
     // }

     // printf("Socket has port #%d\n", ntohs(server.sin_port));
	printf("Socket has port #%d\n",3333);

      /* Start accepting connections */
      lwip_listen(sock, 5);
      do {
		msgsock = lwip_accept(sock, 0, 0);
		if (msgsock == -1)
			perror("accept");
                printf("process message  on msgsock %d \n ",msgsock);
		process_client(msgsock);
	        close(msgsock);
      } while (TRUE);
/*
 * Since this program has an infinite loop, the socket "sock" is
 * never explicitly closed.  However, all sockets will be closed
 * automatically when a process is killed or terminates normally.
 */
}
Пример #9
0
int
mc_event_main(xsMachine *the, mc_event_shutdown_callback_t *cb)
{
	struct timeval tv;
	fd_set rs, ws;
	int n = -1, i;
	unsigned int flags;
	uint64_t timeInterval;
	struct sockaddr_in sin;
	int localevent_sock;

	mc_shutdown_callback = cb;
	g_status = -1;	/* not ready yet */
	if ((localevent_sock = lwip_socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
		return -1;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(MC_LOCAL_EVENT_PORT);
	sin.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
	lwip_bind(localevent_sock, (struct sockaddr *)&sin, sizeof(sin));
	mc_event_register(localevent_sock, MC_SOCK_READ, mc_event_local_callback, the);
	mc_event_delegation_init();
	g_status = 0;	/* running */
	while (!g_status) {
		timeInterval = mc_event_process_timeout(the);
		if (timeInterval != 0) {
			tv.tv_sec = timeInterval / 1000;
			tv.tv_usec = (timeInterval % 1000) * 1000;
		}
		if (maxfd < 0) {	/* @@ what if only timer is running?? */
			mc_log_debug("event: no one is waiting!\n");
			break;	/* no one is waiting for anything! will be blocked forever unless break */
		}
		rs = reads;
		ws = writes;
		n = lwip_select(maxfd + 1, &rs, &ws, NULL, timeInterval > 0 ? &tv : NULL);
		if (mc_event_callback_any.callback != NULL)
			(*mc_event_callback_any.callback)(mc_event_callback_any.fd, (unsigned int)n, mc_event_callback_any.closure);
		if (n > 0) {
			for (i = 0; i <= maxfd; i++) {
				flags = 0;
				if (FD_ISSET(i, &rs))
					flags |= MC_SOCK_READ;
				if (FD_ISSET(i, &ws))
					flags |= MC_SOCK_WRITE;
				if (flags) {
					if (mc_event_callbacks[i].callback == NULL) {
						mc_log_error("event: %s ready for closed socket(%d)!?\n", flags & MC_SOCK_WRITE ? "write" : "read", i);
						continue;
					}
					(*mc_event_callbacks[i].callback)(i, flags, mc_event_callbacks[i].closure);
				}
			}
		}
	}
	mc_event_delegation_fin();
	lwip_close(localevent_sock);
	return g_exit_status;
}
Пример #10
0
static int
test_sockets_alloc_socket_nonblocking(int domain, int type)
{
  int s = lwip_socket(domain, type, 0);
  if (s >= 0) {
    int ret = lwip_fcntl(s, F_SETFL, O_NONBLOCK);
    fail_unless(ret == 0);
  }
  return s;
}
Пример #11
0
THandle OsNetworkCreate(OsNetworkSocketType aSocketType)
{
    int s;
    int type;
    OsNetworkHandle* h;

    //LOG(__FUNCTION__);

    switch ( aSocketType )
    {
        case eOsNetworkSocketStream:
            type = SOCK_STREAM;
            break;
        
        case eOsNetworkSocketDatagram:
            type = SOCK_DGRAM;
            break;
        
        default:
            return kHandleNull;
    }

    h = OsNetworkHandle_Create();

    //LOG("  Created %d\n", HANDLE_TO_SOCKET(h));

    if ( h == kHandleNull )
        return kHandleNull;

    s = lwip_socket(AF_INET, type, 0);

    if ( s < 0 )
    {
        OsNetworkHandle_Destroy(h);
        return kHandleNull;
    }

    if ( type == SOCK_DGRAM )
    {
        char loop = 1;
        if (lwip_setsockopt(s, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)) < 0)
        {
            OsNetworkHandle_Destroy(h);
            return kHandleNull;
        }
    }

    if ( OsNetworkHandle_Initialise(h, s) < 0 )
    {
        OsNetworkHandle_Destroy(h);
        return kHandleNull;
    }
    
    return (THandle) h;
}
Пример #12
0
int socket(int domain, int type, int protocol)
{
    int fd, res;
    fd = lwip_socket(domain, type, protocol);
    if (fd < 0)
	return -1;
    res = alloc_fd(FTYPE_SOCKET);
    printk("socket -> %d\n", res);
    files[res].socket.fd = fd;
    return res;
}
Пример #13
0
void MTD_FLASHMEM UDPClient::init(IPAddress remoteAddress, uint16_t remotePort) {
  m_socket = lwip_socket(AF_INET, SOCK_DGRAM, 0);

  sockaddr_in localAddress = {0};
  localAddress.sin_family = AF_INET;
  localAddress.sin_len = sizeof(sockaddr_in);
  localAddress.sin_addr.s_addr = htonl(INADDR_ANY);
  localAddress.sin_port = htons(getUDPPort());
  lwip_bind(m_socket.getSocket(), (sockaddr *)&localAddress, sizeof(sockaddr_in));

  m_socket.setRemoteAddress(remoteAddress, remotePort);
}
Пример #14
0
static void socketCreate(uint16 sockNr)
{
    int sockFd;
    int sockType;
    struct sockaddr_in sLocalAddr;

    if (SocketAdminList[sockNr].SocketProtocolIsTcp) {
    	sockType = SOCK_STREAM;
    } else {
    	sockType = SOCK_DGRAM;
    }


    sockFd = lwip_socket(AF_INET, sockType, 0);
    if (sockFd >= 0) {
    	memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));

    	int on = 1;
    	lwip_ioctl(sockFd, FIONBIO, &on);
//    	lwip_setsockopt( sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(int) );		// shuzhou add
    	lwip_setsockopt(sockFd, IPPROTO_TCP, TCP_NODELAY, &on, sizeof(int));	// Set socket to no delay

    	/*Source*/
    	sLocalAddr.sin_family = AF_INET;
    	sLocalAddr.sin_len = sizeof(sLocalAddr);

    	sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);		// TODO: Use IP from configuration instead
    	sLocalAddr.sin_port = htons(SocketAdminList[sockNr].SocketConnectionRef->SocketLocalPort);

    	if(lwip_bind(sockFd, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr)) >= 0) {

            if (!SocketAdminList[sockNr].SocketProtocolIsTcp) {
            	// Now the UDP socket is ready for receive/transmit
            	SocketAdminList[sockNr].SocketHandle = sockFd;
            	SocketAdminList[sockNr].SocketState = SOCKET_UDP_READY;
            } else {
                if  ( lwip_listen(sockFd, 20) == 0 ){	// TODO: What number of the backlog?
                	// Now the TCP socket is ready for receive/transmit
                	SocketAdminList[sockNr].SocketHandle = sockFd;
                	SocketAdminList[sockNr].SocketState = SOCKET_TCP_LISTENING;
                } else {
                	lwip_close(sockFd);
                }
            }
    	} else {
    		lwip_close(sockFd);
    	}
    } else {
    	// Socket creation failed
    	// Do nothing, try again later
    }
}
Пример #15
0
Socket::Socket()
{
    int on = 1;

    socket_ = new SocketHandle_t;

    socket_->fd = lwip_socket(PF_INET, SOCK_STREAM, 0);

    lwip_setsockopt(socket_->fd, SOL_SOCKET, SO_REUSEADDR, (char*) &on, sizeof(on));

    /* Set socket non-blocking */
    lwip_ioctl(socket_->fd, FIONBIO, &on);

}
Пример #16
0
int32_t mcs_tcp_init(void (*mcs_tcp_callback)(char *))
{
    int s;
    int c;
    int ret;
    struct sockaddr_in addr;
    int count = 0;
    int rcv_len, rlen;

    int32_t mcs_ret = MCS_TCP_DISCONNECT;

    /* Setting the TCP ip */
    if (HTTPCLIENT_OK != getInitialTCPIP()) {
        return MCS_TCP_INIT_ERROR;
    }

    /* command buffer */
    char cmd_buf [50]= {0};
    strcat(cmd_buf, DEVICEID);
    strcat(cmd_buf, ",");
    strcat(cmd_buf, DEVICEKEY);
    strcat(cmd_buf, ",0");

mcs_tcp_connect:
    os_memset(&addr, 0, sizeof(addr));
    addr.sin_len = sizeof(addr);
    addr.sin_family = AF_INET;
    addr.sin_port = htons(SOCK_TCP_SRV_PORT);
    addr.sin_addr.s_addr =inet_addr(TCP_ip);

    /* create the socket */
    s = lwip_socket(AF_INET, SOCK_STREAM, 0);
    if (s < 0) {
        mcs_ret = MCS_TCP_SOCKET_INIT_ERROR;
        printf("tcp client create fail 0\n");
        goto idle;
    }

    ret = lwip_connect(s, (struct sockaddr *)&addr, sizeof(addr));

    if (ret < 0) {
        lwip_close(s);
        printf("tcp client connect fail 1\n");
        goto mcs_tcp_connect;
    }

    /* timer */
    void tcpTimerCallback( TimerHandle_t pxTimer ) {
        ret = lwip_write(s, cmd_buf, sizeof(cmd_buf));
    }
Пример #17
0
void Test_lwIP()
{
    int server;
    int client;   
    int acceptSock;
    int nonblock;
    int recvd;

    struct sockaddr_in addr, acceptAddr;
    socklen_t len;

    // tcp interface variables 
    struct ip_addr IpAddrLB;
    
    IP4_ADDR( &IpAddrLB, 127,0,0,1); //Loopback  

    addr.sin_family = AF_INET;
    addr.sin_port = 8080;
    addr.sin_addr.s_addr = *(u32_t*)&IpAddrLB;
    addr.sin_len = sizeof(struct sockaddr_in);

    server = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    client = lwip_socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    nonblock = 1;

    if(server == -1 || client == -1) lcd_printf("Sockets were not created!\n");

    if(-1 == lwip_ioctl(server, FIONBIO, (void*)&nonblock)) lcd_printf("Error ioctl 1\n");
    if(-1 == lwip_ioctl(client, FIONBIO, (void*)&nonblock)) lcd_printf("Error ioctl 2\n");

    len = sizeof(addr);

    if(-1 == lwip_bind( server, (const struct sockaddr*)&addr, len ))lcd_printf("Error bind\n");

    if(-1 == lwip_listen( server, 2 )) lcd_printf("Error listen\n");

   / / Set up a tcp connection for client: Bind, Connect
Пример #18
0
//Entry point of ping application.
void ping_Entry(void *arg)
{
  int s;
  int timeout = PING_RCV_TIMEO;
  __PING_PARAM* pParam = (__PING_PARAM*)arg;

  ping_pkt_seq = 0;  //Reset ping sequence number.
	ping_succ    = 0;

  if((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0)
  {
		PrintLine("  ping : Create raw socket failed,quit.");
    return;
  }

  lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
  _hx_printf("\r\n  Ping %s with %d bytes packet:\r\n",inet_ntoa(pParam->targetAddr),pParam->size);
  while (1)
	{
		//ping_target = PING_TARGET; //ping gw
		//IP4_ADDR(&ping_target, 127,0,0,1); //ping loopback.
    if (ping_send(s, &pParam->targetAddr,pParam->size) == ERR_OK)
		{
			//printf(" ping_Entry : Send out packet,addr = %s,size = %d\r\n",inet_ntoa(pParam->targetAddr),pParam->size);
      ping_time = sys_now();
      ping_recv(s);
	    ping_pkt_seq ++;
    }
	  else
	  {
	    PrintLine("   ping : Send out packet failed.");
    }
    //sys_msleep(PING_DELAY);

	  //Try the specified times.
	  pParam->count --;
	  if(0 == pParam->count)
	  {
		  break;
	  }
  }
	//Show ping statistics.
	_hx_printf("\r\n");
	_hx_printf("  ping statistics: total send = %d,received = %d,%d loss.\r\n",
	  ping_pkt_seq,ping_succ,(ping_pkt_seq - ping_succ));
  //Close socket.
  lwip_close(s);
}
Пример #19
0
int socket(int domain, int type, int protocol) {

	if(!BT_isNetworkingReady()) {
		return -1;
	}

	BT_ERROR Error;
	BT_HANDLE hSocket = BT_CreateHandle(&oHandleInterface, sizeof(struct _BT_OPAQUE_HANDLE), &Error);
	if(!hSocket) {
		return 0;
	}

	hSocket->socket = lwip_socket(domain, type, protocol);

	return (int)hSocket;
}
Пример #20
0
int socket_init_socket(struct mySocket *sock, int type) {
	sock->_sock_fd = -1;
	sock->_blocking = 1;
	sock->_timeout.tv_sec = 1;
	sock->_timeout.tv_usec = 500;

	if (sock->_sock_fd != -1)
		return -1;
    
	int fd = lwip_socket(AF_INET, type, 0);
	if (fd < 0)
		return -1;
    
	sock->_sock_fd = fd;
	return 0;
}
Пример #21
0
void rx_application_thread()
{
	int sock, new_sd;
	struct sockaddr_in address, remote;
	int size;

	if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)
		return;

	address.sin_family = AF_INET;
	address.sin_port = htons(rxperf_port);
	address.sin_addr.s_addr = INADDR_ANY;

	if (lwip_bind(sock, (struct sockaddr *)&address, sizeof (address)) < 0) {
#ifdef OS_IS_FREERTOS
		vTaskDelete(NULL);
#endif
		return;
	}

	lwip_listen(sock, 0);

	size = sizeof(remote);
	new_sd = lwip_accept(sock, (struct sockaddr *)&remote, (socklen_t*)&size);

	while (1) {
#if (USE_JUMBO_FRAMES==1)
		char recv_buf[9700];
		/* keep reading data */
		if (lwip_read(new_sd, recv_buf, 8000) <= 0)
			break;
#else
		char recv_buf[1500];
		/* keep reading data */
		if (lwip_read(new_sd, recv_buf, 1460) <= 0)
			break;
#endif
	}

	print("Connection closed. RXPERF exiting.\r\n");

    lwip_close(new_sd);
#ifdef OS_IS_FREERTOS
	xil_printf("Rx IPERF Thread is being DELETED\r\n");
    vTaskDelete(NULL);
#endif
}
Пример #22
0
static void receive_udp(void *pvParameters) {
    int lSocket;
    struct sockaddr_in sLocalAddr, sDestAddr;

    int nbytes;
    int i;
    lSocket = lwip_socket(AF_INET, SOCK_DGRAM, 0);
    if(lSocket != 0) {
        printf("ERROR \r\n");
    }

    memset((char *)&sLocalAddr, 0, sizeof(sLocalAddr));
    memset((char *)&sDestAddr, 0, sizeof(sDestAddr));

    /*Destination*/
    sDestAddr.sin_family = AF_INET;
    sDestAddr.sin_len = sizeof(sDestAddr);
    sDestAddr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
    sDestAddr.sin_port = htons(8080);

    /*Source*/
    sLocalAddr.sin_family = AF_INET;
    sLocalAddr.sin_len = sizeof(sLocalAddr);
    sLocalAddr.sin_addr.s_addr = htonl(INADDR_ANY); //inet_addr("192.168.4.1");
    sLocalAddr.sin_port = htons(8080);

    int err = lwip_bind(lSocket, (struct sockaddr *)&sLocalAddr, sizeof(sLocalAddr));
    if(err != 0) {
        printf("ERROR \r\n");
    }
    while (1) {
        nbytes=lwip_recv(lSocket, buffer, sizeof(buffer),8);
        if (nbytes>0) {
            //lwip_sendto(lSocket, buffer, nbytes, 0, (struct sockaddr *)&sDestAddr, sizeof(sDestAddr));
            char * dat = malloc(nbytes);
            memcpy(dat, buffer, nbytes);
            dat[nbytes] = 0;
            my_event_t ev;
            ev.event_type = EVT_DATA;
            ev.data = dat;
            ev.len = nbytes;
            xQueueSend(mainqueue, &ev, 0);
        }
    }
    lwip_close(lSocket);
}
Пример #23
0
static void
ping_thread(void *arg)
{
	int s;
	LWIP_UNUSED_ARG(arg);

	if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
		return;
	}

	while (1) {
		printf("sending ping\n");
		ping_send(s,&ping_addr);
		ping_recv(s,&ping_addr);
		sleep(1);
	}
}
Пример #24
0
/**
  Open a new TCP socket.
  Be sure to close any sockets you open - otherwise, you won't be able to open any new ones.
  @param address The IP address to connect to - use the IP_ADDRESS macro if needed.
  @param port The port to connect on.
  @return A handle to the new socket, or -1 if it failed to connect.
  
  \b Example
  \code
  int sock = tcpOpen(IP_ADDRESS(192, 168, 0, 210), 11101);
  if (sock > -1) {
    // then we got a good connection
    // ...reading & writing...
    tcpClose(sock); // make sure to close it if we connected
  }
  \endcode
*/
int tcpOpen(int address, int port)
{
  int sock = lwip_socket(0, SOCK_STREAM, IPPROTO_TCP);
  if (sock >= 0) {
    struct sockaddr_in to = {
      .sin_family = AF_INET,
      .sin_addr.s_addr = address,
      .sin_port = htons(port)
    };

    if (lwip_connect(sock, (const struct sockaddr*)&to, sizeof(to)) != 0) {
      lwip_close(sock);
      sock = -1;
    }
  }
  return sock;
}
Пример #25
0
void buttonConnectPressed(void* source) {

    struct sockaddr_in addr;
    int ret;

    ((button_t*)source)->hasBeenAcknowledged = 1;

    setStatus(CONNECTING);

    if (!isConnected) {

        memset(&addr, 0, sizeof(addr));
        addr.sin_len = sizeof(addr);
        addr.sin_family = AF_INET;
        addr.sin_port = PP_HTONS(SOCK_TARGET_PORT);
        addr.sin_addr.s_addr = inet_addr(SOCK_TARGET_HOST);

        socket_in = lwip_socket(AF_INET, SOCK_STREAM, 0);

        if ((ret = lwip_connect(socket_in, (struct sockaddr*)&addr, sizeof(addr))) == 0) {
            isConnected = 1;

            executeCommand(IDENT);
            executeCommand(END_IDENT);

            setStatus(CONNECTED);

        }
        else {
            isConnected = 0;
            setStatus(DISCONNECTED);
        }
    }
    else {

        if ((ret = lwip_close(socket_in)) == 0) {
            setStatus(DISCONNECTED);
            isConnected = 0;
            resetBoards();
            setVersion(NULL);
        }
    }

    refreshBoards();
}
Пример #26
0
static void post_int(OsNetworkHandle* aHandle)
{
    // Send byte to interrupt socket
    int sender = lwip_socket ( AF_INET, SOCK_DGRAM, 0 );
    struct sockaddr_in s;
    s.sin_family        = AF_INET;
    s.sin_port          = htons( 10000 + HANDLE_TO_SOCKET(aHandle) );   // relate port to fd
    s.sin_addr.s_addr   = IPADDR_LOOPBACK;                              // localhost

    char buffer[] = { 0xaa };

    int bytes = lwip_sendto ( sender, buffer, 1, 0, (struct sockaddr*) &s, sizeof(s) );
    
    if ( bytes != sizeof(buffer) )
        exit(-1);
    
    lwip_close(sender);
}
Пример #27
0
/* ------------------------------------------------------------------------------------------------------
 *									   sockex_nonblocking_connect()
 *
 * Description : Handing socket receive data.
 *
 * Argument(s) : none.
 *
 */
void sockex_testrecv(void *arg)
{
//	int ret;
	struct sockaddr_in servaddr, cliaddr;
//	struct timeval tv;
	unsigned long cliaddr_len;
	
	LWIP_UNUSED_ARG(arg);

	memset(&servaddr, 0, sizeof(servaddr));							/* set up address to connect to */
	servaddr.sin_len = sizeof(servaddr);
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = PP_HTONS(SOCK_HOSR_PORT);
	servaddr.sin_addr.s_addr = lwIPLocalIPAddrGet();				/* Set local IP address.*/

	listenfd = lwip_socket(AF_INET, SOCK_STREAM, 0);

	lwip_bind(listenfd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr));

	lwip_listen(listenfd, SOCK_HOSR_PORT);

	RS232printf("Accepting connections ...\n");
	
	cliaddr_len = sizeof(cliaddr);
	
	for(;;)
	{
		connfd = lwip_accept(listenfd, (struct sockaddr *)&cliaddr, &cliaddr_len);
		if(connfd <= 0)
		{
			OSTimeDly(2);
			continue;
		}
		else
		{
			connfd = connfd;
			RS232printf("cli is ok!");
		}
//		lwip_select();
		
		OSTimeDly(2);
	}
}
Пример #28
0
static void
ping_thread(void *arg)
{
  int s;
  struct ip_addr dest_addr;

  if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
    return;
  }

  IP4_ADDR(&dest_addr,192,168,2,1);

  while (1) {
    printf("sending ping\n");
    ping_send(s,&dest_addr);
    ping_recv(s,&dest_addr);
    sleep(1);
  }
}
static void
ping_host_thread(void *arg)
{
  int s,i=0;
  int timeout = PING_RCV_TIMEO;
  ip_addr_t ping_target;
  char *host = (char *)arg;
  //LWIP_UNUSED_ARG(arg);

  if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) {
    return;
  }

  lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

  while (1) {
    //ping_target = PING_TARGET;
	if (i>4) break;
	i++;  
	(ip4_addr_set_u32(&ping_target, ipaddr_addr(host)));

    if (ping_send(s, &ping_target) == ERR_OK) {
      //LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
      //ip_addr_debug_print(PING_DEBUG, &ping_target);
      //LWIP_DEBUGF( PING_DEBUG, ("\n"));
			rt_kprintf("ping: send ");
			ip_addr_debug_print1(&ping_target);
			rt_kprintf("\n");
		
      ping_time = sys_now();
      ping_recv(s);
    } else {
      //LWIP_DEBUGF( PING_DEBUG, ("ping: send "));
      //ip_addr_debug_print(PING_DEBUG, &ping_target);
      //LWIP_DEBUGF( PING_DEBUG, (" - error\n"));
			rt_kprintf("ping: send ");
			ip_addr_debug_print1(&ping_target);
			rt_kprintf(" - error\n");
    }
    sys_msleep(PING_DELAY);
  }
}
Пример #30
0
/* http server */
int
web_application_thread()
{
    int sock, new_sd;
    struct sockaddr_in address, remote;
    socklen_t size;

    /* create a TCP socket */
    if ((sock = lwip_socket(AF_INET, SOCK_STREAM, 0)) < 0)
        return 0;

    /* bind to port 80 at any interface */
    address.sin_family = AF_INET;
    address.sin_port = htons(http_port);
    address.sin_addr.s_addr = INADDR_ANY;
    if (lwip_bind(sock, (struct sockaddr *) &address, sizeof(address)) < 0)
        return 0;

    /* listen for incoming connections */
    lwip_listen(sock, 5);

    size = sizeof(remote);
    while (1) {
    	sys_thread_t new_thread;

        new_sd =
            lwip_accept(sock, (struct sockaddr *) &remote,
                        &size);

        /* spawn a separate handler for each request */
        new_thread = sys_thread_new("httpd", (void (*)(void *)) process_http_request,
                       (void *) new_sd, THREAD_STACKSIZE, DEFAULT_THREAD_PRIO);

        /* close connection if no new threads available */
        if (new_thread == 0) {
            close(new_sd);
        }
    }

    return 0;
}