自学教程：C++ uip_listen函数代码示例

void listen_init(void){	//80端口用于web页面	uip_listen(HTONS(8079));  //用于串口波特率设置	uip_listen(HTONS(8080));  //用于收发数据	uip_listen(HTONS(80));	/* http server */}

/** * /brief Start listening to the specified port. Standard BSD listen() with internal name. * /param[in] desc socket descriptor to start listening on. * /param[in] maxcon is be the maximum TCP connections to accept on that socket. Unsued parameter with current implementation. * /details To accept connections, a socket is first created with socket(),             a willingness to accept incoming connections is specified with listen(),             and then the connections are accepted with accept(). The listen() call applies only to sockets of type /ref SOCK_STREAM (TCP). * /note Default maximum number of connections unknown? * /return On connection success, zero is returned. On error, -1 is returned. * /callgraph */int _sys_sock_listen(int fd,int maxcon){#if defined (__KERNEL_NET_IPSTACK) && defined (USE_UIP_CORE)   pid_t pid;   kernel_pthread_t* pthread_ptr;   hsock_t hsock  = 0;   desc_t desc;   //   //   if(!(pthread_ptr = kernel_pthread_self())){      __set_kernel_pthread_errno(ESRCH);      return -1;   }   if((pid=pthread_ptr->pid)<=0){      __set_kernel_pthread_errno(ESRCH);      return -1;   }   //   if(fd<0){      __set_kernel_pthread_errno (EBADF);      return -1;   }   //   desc = process_lst[pid]->desc_tbl[fd];   if(desc<0){      __set_kernel_pthread_errno (EBADF);      return -1;   }   if(!ofile_lst[desc].used){      __set_kernel_pthread_errno (EBADF);      return -1;   }   if(! (hsock  = ofile_lst[desc].p) ){      __set_kernel_pthread_errno (ENOTSOCK);      return -1;   }   if(((socket_t*)hsock)->protocol!=IPPROTO_TCP){      __set_kernel_pthread_errno (EPROTONOSUPPORT);      return -1;   }   //lock   __lock_io(ofile_lst[desc].owner_pthread_ptr_write,desc,O_WRONLY);   __lock_io(ofile_lst[desc].owner_pthread_ptr_read,desc,O_RDONLY);   //   ((socket_t*)hsock)->state = STATE_SOCKET_LISTEN;   #if UIP_CONF_IPV6   uip_listen( (u16_t)( ((socket_t*)hsock)->addr_in.sin6_port) );   #else   uip_listen( (u16_t)( ((socket_t*)hsock)->addr_in.sin_port) );   #endif   //unlock   __unlock_io(ofile_lst[desc].owner_pthread_ptr_write,desc,O_WRONLY);   __unlock_io(ofile_lst[desc].owner_pthread_ptr_read,desc,O_RDONLY);   //   __set_kernel_pthread_errno (0);   //   return 0;#else   return -1;#endif} //end of _sys_sock_listen()

voidnetwork_init(void){	uip_listen(HTONS(NETWORK_PORT_GCODE));	uip_listen(HTONS(NETWORK_PORT_DEBUG));		// Listen on a UDP port	uip_ipaddr_t addr;	struct uip_udp_conn *c;	uip_ipaddr(&addr, 0,0,0,0);	c = uip_udp_new(&addr, HTONS(0));	if(c != NULL)		uip_udp_bind(c, HTONS(NETWORK_PORT_GCODE));}

// Accept a connection on the given port, return its socket id (and the IP of the remote host by side effect)int elua_accept( u16 port, unsigned timer_id, u32 to_us, elua_net_ip* pfrom ){  u32 tmrstart = 0;  int old_status;    if( !elua_uip_configured )    return -1;#ifdef BUILD_CON_TCP  if( port == ELUA_NET_TELNET_PORT )    return -1;#endif    old_status = platform_cpu_set_global_interrupts( PLATFORM_CPU_DISABLE );  uip_unlisten( htons( port ) );  uip_listen( htons( port ) );  platform_cpu_set_global_interrupts( old_status );  elua_uip_accept_sock = -1;  elua_uip_accept_request = 1;  if( to_us > 0 )    tmrstart = platform_timer_op( timer_id, PLATFORM_TIMER_OP_START, 0 );  while( 1 )  {    if( elua_uip_accept_request == 0 )      break;    if( to_us > 0 && platform_timer_get_diff_us( timer_id, tmrstart, platform_timer_op( timer_id, PLATFORM_TIMER_OP_READ, 0 ) ) >= to_us )    {      elua_uip_accept_request = 0;      break;    }  }    *pfrom = elua_uip_accept_remote;  return elua_uip_accept_sock;}

void web_init(void){	fls = newHashObject();	fls->addIndexString(fls, "/index.html", indexPage);	uip_listen(HTONS(80));}

/*---------------------------------------------------------------------------*/voidtelnetd_init(void){  uip_listen(HTONS(23));  memb_init(&linemem);  shell_init();}

/*-----------------------------------------------------------------------------------*/void httpd_init(void){  fs_init();    /* Listen to port 80. */  uip_listen(HTONS(80));}

//port number must be in network order (use htons() )bool socket_listen( unsigned short port, file_handle_t (*accept_callback)(u16_t local_port, u16_t *remote_address, u16_t remote_port) ){    int i = uip_listen( port );    if( i < 0 ) return false;    listenports[i] = accept_callback;    return true;}

/** Initialization function for the simple HTTP webserver. */void HTTPServerApp_Init(void){	/* Listen on port 80 for HTTP connections from hosts */	uip_listen(HTONS(HTTP_SERVER_PORT));		/* Mount the dataflash disk via FatFS */	f_mount(0, &DiskFATState);}

//*****************************************************************************//// Initialize the web server.//// Starts to listen for incoming connection requests on TCP port 80.////*****************************************************************************voidhttpd_init(void){    //    // Listen to port 80.    //    uip_listen(HTONS(80));}

voidhttpd_init(void) {  uip_listen(HTONS(80));  PIN_UNUSED(j1[0]);  PIN_UNUSED(j1[1]); // PB5  SETUP_PIN(j1[2], GPIO_PORTB_BASE, GPIO_PIN_0, CONFIG_INPUT);  SETUP_PIN(j1[3], GPIO_PORTB_BASE, GPIO_PIN_1, CONFIG_INPUT);  SETUP_PIN(j1[4], GPIO_PORTE_BASE, GPIO_PIN_4, CONFIG_INPUT);  PIN_UNUSED(j1[5]); // PE5  PIN_UNUSED(j1[6]); // PB4  PIN_UNUSED(j1[7]); // PA5  SETUP_PIN(j1[8], GPIO_PORTA_BASE, GPIO_PIN_6, CONFIG_INPUT);  SETUP_PIN(j1[9], GPIO_PORTA_BASE, GPIO_PIN_7, CONFIG_INPUT);  PIN_UNUSED(j2[0]); // GND  SETUP_PIN(j2[1], GPIO_PORTB_BASE, GPIO_PIN_2, CONFIG_INPUT);  SETUP_PIN(j2[2], GPIO_PORTE_BASE, GPIO_PIN_0, CONFIG_INPUT);  PIN_UNUSED(j2[3]); // PF0 -- not used  PIN_UNUSED(j2[4]); // RESET  PIN_UNUSED(j2[5]); // PB7 -- used by SSI2  PIN_UNUSED(j2[6]); // PB6 -- used by SSI2  SETUP_PIN(j2[7], GPIO_PORTA_BASE, GPIO_PIN_4, CONFIG_INPUT);  SETUP_PIN(j2[8], GPIO_PORTA_BASE, GPIO_PIN_3, CONFIG_INPUT);  SETUP_PIN(j2[9], GPIO_PORTA_BASE, GPIO_PIN_2, CONFIG_INPUT);  PIN_UNUSED(j3[0]); // 5.0V  PIN_UNUSED(j3[1]); // GND  SETUP_PIN(j3[2], GPIO_PORTD_BASE, GPIO_PIN_0, CONFIG_INPUT);  SETUP_PIN(j3[3], GPIO_PORTD_BASE, GPIO_PIN_1, CONFIG_INPUT);  SETUP_PIN(j3[4], GPIO_PORTD_BASE, GPIO_PIN_2, CONFIG_INPUT);  SETUP_PIN(j3[5], GPIO_PORTD_BASE, GPIO_PIN_3, CONFIG_INPUT);  SETUP_PIN(j3[6], GPIO_PORTE_BASE, GPIO_PIN_1, CONFIG_INPUT);  SETUP_PIN(j3[7], GPIO_PORTE_BASE, GPIO_PIN_2, CONFIG_INPUT);  SETUP_PIN(j3[8], GPIO_PORTE_BASE, GPIO_PIN_3, CONFIG_INPUT);  SETUP_PIN(j3[9], GPIO_PORTF_BASE, GPIO_PIN_1, CONFIG_OUTPUT);  SETUP_PIN(j4[0], GPIO_PORTF_BASE, GPIO_PIN_2, CONFIG_OUTPUT);  SETUP_PIN(j4[1], GPIO_PORTF_BASE, GPIO_PIN_3, CONFIG_OUTPUT);  SETUP_PIN(j4[2], GPIO_PORTB_BASE, GPIO_PIN_3, CONFIG_INPUT);  SETUP_PIN(j4[3], GPIO_PORTC_BASE, GPIO_PIN_4, CONFIG_INPUT);  SETUP_PIN(j4[4], GPIO_PORTC_BASE, GPIO_PIN_5, CONFIG_INPUT);  SETUP_PIN(j4[5], GPIO_PORTC_BASE, GPIO_PIN_6, CONFIG_INPUT);  SETUP_PIN(j4[6], GPIO_PORTC_BASE, GPIO_PIN_7, CONFIG_INPUT);  SETUP_PIN(j4[7], GPIO_PORTD_BASE, GPIO_PIN_6, CONFIG_INPUT);  SETUP_PIN(j4[8], GPIO_PORTD_BASE, GPIO_PIN_7, CONFIG_INPUT);  SETUP_PIN(j4[9], GPIO_PORTF_BASE, GPIO_PIN_4, CONFIG_INPUT);  MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);  MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);  MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);  MAP_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);  configure_pins(j1, HEADER_SIZE);  configure_pins(j2, HEADER_SIZE);  configure_pins(j3, HEADER_SIZE);  configure_pins(j4, HEADER_SIZE);}

void srv_listen(uint16_t port){	// Check if a listening point was already open	for(U8 i=0;i<MAX_SOCK_NUM;i++)		if(uip_listenports[i] == HTONS(port))			return;		// Start listening		uip_listen(HTONS(port));}

/* * The initialization function. We must explicitly call this function * from the system initialization code, some time after uip_init() is * called. */voidiot_tcp_app_init(void){    /* We start to listen for connections on TCP port 7681. */    uip_listen(HTONS(IoTpAd.ComCfg.Local_TCP_Srv_Port));#if CFG_SUPPORT_TCPIP_ROBUST_TEST    uip_listen(HTONS(7684));#endif#if UIP_HTTP_CLIENT_SUPPORT    //http client setting    //webclient_get("192.168.1.100", HTTP_SERVER_DEFAULT_PORT, "/MT7681_sta_header.bin");    webclient_get("192.168.2.1", HTTP_SERVER_DEFAULT_PORT, "/index.html");    //printf_high("http client port:%d/n", http_clientPort);    uip_listen(HTONS(http_clientPort));#endif#if TCP_CLI_APP1_ENABLE    tcp_cli_app1_init();#endif#if TCP_SRV_APP1_ENABLE    uip_listen(HTONS(TCP_SRV_APP1_LOCAL_PORT));#endif#if MY_TCP_SRV_APP_ENABLE    uip_listen(HTONS(MY_TCP_SRV_APP_LOCAL_PORT));#endif#if UIP_CLOUD_SERVER_SUPPORT    uip_listen(HTONS(CLOUD_TCP_SERVER_PORT));    cloud_para_check_connect();#endif}

void xtcpd_listen(int linknum, int port_number, xtcp_protocol_t p){    if (p == XTCP_PROTOCOL_TCP) {        register_listener(tcp_listeners, linknum, port_number, NUM_TCP_LISTENERS);        uip_listen(HTONS(port_number));    }    else {        register_listener(udp_listeners, linknum, port_number, NUM_UDP_LISTENERS);        uip_udp_listen(HTONS(port_number));    }    return;}

void netSockListen(UosFile* file){  P_ASSERT("netSockListen", file->fs->cf == &netFSConf);  NetSock* sock = (NetSock*)file->fsPriv;  posMutexLock(sock->mutex);  sock->state = NET_SOCK_LISTENING;  posMutexUnlock(sock->mutex);  posMutexLock(uipMutex);  uip_listen(sock->port);  posMutexUnlock(uipMutex);}

/** * /brief      Initialize the web server * *             This function initializes the web server and should be *             called at system boot-up. */voidhttpd_init(void){#if PORT_APP_MAPPER	uint8_t index = 0;	while (index < HTTPD_MAX_CONNECTIONS)	{		httpd_state_list[index].state = STATE_UNUSED;		index++;	}#endif	uip_listen(HTONS(80));}

/* * The initialization function. We must explicitly call this function * from the system initialization code, after uip_init() is called. */void ftpd_init(void){    u16_t i;    // Initialise the ftp daemons    for (i = 0; i < NUM_FTP_DAEMONS; i++)    {        ftpd_state[i].state = FTP_UNUSED;        ftpd_state[i].pasvport = PASV_PORT_OFFSET + i;    }    /* We start to listen for connections on the FTP control port. */    uip_listen(HTONS(FTPD_CONTROL_PORT));}

/** Initialization function for the DHCP server. */void DHCPServerApp_Init(void){	/* Listen on port 67 for DHCP server connections from hosts */	uip_listen(HTONS(DHCP_SERVER_PORT));	/* Create a new UDP connection to the DHCP server port for the DHCP solicitation */	struct uip_udp_conn* BroadcastConnection = uip_udp_new(&uip_broadcast_addr, HTONS(DHCP_CLIENT_PORT));	/* If the connection was successfully created, bind it to the local DHCP client port */	if (BroadcastConnection != NULL)	  uip_udp_bind(BroadcastConnection, HTONS(DHCP_SERVER_PORT));	/* Set all IP addresses as unleased */	memset(LeasedIPs, 0x00, sizeof(LeasedIPs));}

/*---------------------------------------------------------------------------*/voidtcp_listen(uint16_t port, uint8_t conn_id){  static unsigned char i;  struct listenport *l;  l = s.listenports;  for(i = 0; i < UIP_LISTENPORTS; ++i) {    if(l->port == 0) {      l->port = port;      l->conn_id = conn_id;      uip_listen(port);      break;    }    ++l;  }}

static void setup_servers(){    if (webserver_enabled) {        // Initialize the HTTP server, listen to port 80.        httpd_init();        printf("Webserver initialized/n");    }    if (telnet_enabled) {        // Initialize the telnet server        Telnetd::init();        printf("Telnetd initialized/n");    }    // sftpd service, which is lazily created on reciept of first packet    uip_listen(HTONS(115));}

/*---------------------------------------------------------------------------*/voidtcp_listen(u16_t port, uip_app_handle_t p){  static unsigned char i;  struct listenport *l;  l = s.listenports;  for(i = 0; i < UIP_LISTENPORTS; ++i) {    if(l->port == 0) {      l->port = port;      l->p = p;      uip_listen(port);      break;    }    ++l;  }}

/*---------------------------------------------------------------------------*/voidtcp_listen(uint16_t port){    static unsigned char i;    struct listenport *l;    l = s.listenports;    for(i = 0; i < UIP_LISTENPORTS; ++i) {        if(l->port == 0) {            l->port = port;            l->p = PROCESS_CURRENT();            uip_listen(port);            break;        }        ++l;    }}

/** * @brief   Configure Network * @param   None * @retval  None */void Network_Configuration(void){	struct uip_eth_addr mac = {{ 0xeb, 0xa0, 0x00, 0x00, 0x00, 0x00 }};	enc28j60_init(mac.addr);	uip_init();	uip_arp_init();	uip_setethaddr(mac);	uip_ipaddr_t ipaddr;	uip_ipaddr(ipaddr, 192, 168, 0, 100);	uip_sethostaddr(ipaddr);	uip_ipaddr(ipaddr, 255, 255, 255, 0);	uip_setnetmask(ipaddr);	uip_ipaddr(ipaddr, 192, 168, 0, 1);	uip_setdraddr(ipaddr);	uip_listen(HTONS(4000));}

void TcpIpInit(void){   uint8_t                                 IpAddress[4];   uint8_t                                 NetMask[4];   uint8_t                                 RouterIp[4];   /* Set up the network interface */   UserIoIpSettingsGet(IpAddress, NetMask, RouterIp);   nic_init();   uip_init(IpAddress, NetMask, RouterIp);   uip_arp_init();   uip_listen(HTONS(ETH_LOC_BUFFER_BUFFER_TCP_PORT));   TcpIpUipTimerCounter = 0;   TcpIpUipArpTimerCounter = 0;   TCCR0B = (1 << CS01) | (1<<CS00);   TIMSK0 |= (1<<TOIE0);}

/* -------------------------------------------------------------------------- */void xtcpd_listen(int linknum, int port_number, xtcp_protocol_t p){	switch(p){	case XTCP_PROTOCOL_TCP:	    register_listener(tcp_listeners, linknum, port_number, NUM_TCP_LISTENERS);	    uip_listen(HTONS(port_number));		break;	case XTCP_PROTOCOL_UDP:	    register_listener(udp_listeners, linknum, port_number, NUM_UDP_LISTENERS);	    uip_udp_listen(HTONS(port_number));		break;	default:		PRINTF("xtcpd_listen: Unknown protocol.");		break;	}  return;}

/* ----------------------- Begin implementation -----------------------------*/BOOLxMBTCPPortInit( USHORT usTCPPort ){    BOOL bOkay = FALSE;    USHORT usPort;    if( usTCPPort == 0 )    {        usPort = MB_TCP_DEFAULT_PORT;    }    else    {        usPort = (USHORT)usTCPPort;    }    // 侦听端口 502端口    uip_listen(HTONS(usPort));    bOkay = TRUE;    return bOkay;}

// Init applicationvoid elua_uip_init( const struct uip_eth_addr *paddr ){  // Set hardware address  uip_setethaddr( (*paddr) );    // Initialize the uIP TCP/IP stack.  uip_init();  uip_arp_init();    #ifdef BUILD_DHCPC  dhcpc_init( paddr->addr, sizeof( *paddr ) );  dhcpc_request();#else  elua_uip_conf_static();#endif    resolv_init();  #ifdef BUILD_CON_TCP  uip_listen( HTONS( ELUA_NET_TELNET_PORT ) );#endif  }

void Server::init(pageServingFunction function) {	// WiShield init	zg_init();#ifdef USE_DIG0_INTR	attachInterrupt(0, zg_isr, LOW);#endif#ifdef USE_DIG8_INTR	// set digital pin 8 on Arduino	// as ZG interrupt pin	PCICR |= (1<<PCIE0);	PCMSK0 |= (1<<PCINT0);#endif	while(zg_get_conn_state() != 1) {		zg_drv_process();	}	// Start the stack	stack_init();	// Store the callback function for serving pages	// and start listening for connections on port 80 if	// the function is non-null	callbackFunc = function;	if (callbackFunc) {		// Listen for server requests on port 80		uip_listen(HTONS(80));	}#ifdef DEBUG	verbose = true;	Serial.println("WiServer init called");#endif // DEBUG}

voidhttpd_init(void){  uip_listen(HTONS(HTTPD_PORT), httpd_main);  uip_listen(HTONS(HTTPD_ALTERNATE_PORT), httpd_main);}