static __inline void unlink_dyn_rule_print(struct ipfw_flow_id *id) { struct in_addr da; #ifdef INET6 char src[INET6_ADDRSTRLEN], dst[INET6_ADDRSTRLEN]; #else char src[INET_ADDRSTRLEN], dst[INET_ADDRSTRLEN]; #endif #ifdef INET6 if (IS_IP6_FLOW_ID(id)) { ip6_sprintf(src, &id->src_ip6); ip6_sprintf(dst, &id->dst_ip6); } else #endif { da.s_addr = htonl(id->src_ip); inet_ntoa_r(da, src); da.s_addr = htonl(id->dst_ip); inet_ntoa_r(da, dst); } printf("ipfw: unlink entry %s %d -> %s %d, %d left\n", src, id->src_port, dst, id->dst_port, V_dyn_count - 1); }
/********************************************************************************************************* ** 函数名称: __aodvEntryPrint ** 功能描述: 打印 aodv 路由信息 ** 输 入 : rt aodv 路由条目 ** pcBuffer 缓冲区 ** stSize 缓冲区大小 ** pstOffset 偏移量 ** 输 出 : NONE ** 全局变量: ** 调用模块: *********************************************************************************************************/ static VOID __aodvEntryPrint (struct aodv_rtnode *rt, PCHAR pcBuffer, size_t stSize, size_t *pstOffset) { CHAR cIpDest[INET_ADDRSTRLEN]; CHAR cNextHop[INET_ADDRSTRLEN]; CHAR cMask[INET_ADDRSTRLEN]; CHAR cFlag[16] = "\0"; CHAR cIfName[IF_NAMESIZE] = "\0"; inet_ntoa_r(rt->dest_addr, cIpDest, INET_ADDRSTRLEN); inet_ntoa_r(rt->next_hop, cNextHop, INET_ADDRSTRLEN); if (rt->state & AODV_VALID) { lib_strcat(cFlag, "U"); } if (rt->hcnt > 0) { lib_strcat(cFlag, "G"); } if ((rt->flags & AODV_RT_GATEWAY) == 0) { lib_strcat(cFlag, "H"); } if ((rt->flags & AODV_RT_UNIDIR) == 0) { /* 单向连接 */ lib_strcat(cFlag, "-ud"); } /* * aodv 路由节点网络接口一定有效 */ ipaddr_ntoa_r(&rt->netif->netmask, cMask, INET_ADDRSTRLEN); if_indextoname(rt->netif->num, cIfName); *pstOffset = bnprintf(pcBuffer, stSize, *pstOffset, "%-18s %-18s %-18s %-8s %8d %-3s\n", cIpDest, cNextHop, cMask, cFlag, rt->hcnt, cIfName); }
/* * Format an IPv4 address, more or less like inet_ntoa(). * * Returns `dst' (as a const) * Note: * - uses no statics * - takes a unsigned char* not an in_addr as input */ static char *inet_ntop4 (const unsigned char *src, char *dst, size_t size) { #if defined(HAVE_INET_NTOA_R_2_ARGS) const char *ptr; DEBUGASSERT(size >= 16); ptr = inet_ntoa_r(*(struct in_addr*)src, dst); return (char *)memmove(dst, ptr, strlen(ptr)+1); #elif defined(HAVE_INET_NTOA_R) #if defined(HAVE_INT_INET_NTOA_R) return inet_ntoa_r(*(struct in_addr*)src, dst, size)? NULL: dst; #else return inet_ntoa_r(*(struct in_addr*)src, dst, size); #endif #else const char *addr = inet_ntoa(*(struct in_addr*)src); if(strlen(addr) >= size) { SET_ERRNO(ENOSPC); return (NULL); } return strcpy(dst, addr); #endif }
char * uinet_inet_ntoa(struct uinet_in_addr in, char *buf, unsigned int size) { (void)size; return inet_ntoa_r(*((struct in_addr *)&in), buf); }
int ObTbnetCallback::shadow_process(easy_request_t* r) { int ret = EASY_OK; if (NULL == r || NULL == r->ipacket) { TBSYS_LOG(ERROR, "request is empty, r = %p, r->ipacket = %p", r, r->ipacket); ret = EASY_BREAK; } else { ObShadowServer *server = (ObShadowServer*)r->ms->c->handler->user_data; ObPacket *req = (ObPacket*) r->ipacket; req->set_request(r); ret = server->handlePacket(req); if (OB_SUCCESS == ret) { r->ms->c->pool->ref++; easy_atomic_inc(&r->ms->pool->ref); easy_pool_set_lock(r->ms->pool); ret = EASY_AGAIN; } else { ret = EASY_OK; TBSYS_LOG(WARN, "can not push packet(src is %s, pcode is %u) to packet queue", inet_ntoa_r(r->ms->c->addr), req->get_packet_code()); } } return ret; }
char *Curl_if2ip(const char *interface, char *buf, int buf_size) { int dummy; char *ip=NULL; if(!interface) return NULL; dummy = socket(AF_INET, SOCK_STREAM, 0); if (SYS_ERROR == dummy) { return NULL; } else { struct ifreq req; size_t len = strlen(interface); memset(&req, 0, sizeof(req)); if(len >= sizeof(req.ifr_name)) return NULL; /* this can't be a fine interface name */ memcpy(req.ifr_name, interface, len+1); req.ifr_addr.sa_family = AF_INET; #ifdef IOCTL_3_ARGS if (SYS_ERROR == ioctl(dummy, SIOCGIFADDR, &req)) { #else if (SYS_ERROR == ioctl(dummy, SIOCGIFADDR, &req, sizeof(req))) { #endif sclose(dummy); return NULL; } else { struct in_addr in; union { struct sockaddr_in *sin; struct sockaddr *s; } soadd; soadd.s = &req.ifr_dstaddr; memcpy(&in, &(soadd.sin->sin_addr.s_addr), sizeof(in)); #if defined(HAVE_INET_NTOA_R) ip = inet_ntoa_r(in,buf,buf_size); #else ip = strncpy(buf,inet_ntoa(in),buf_size); ip[buf_size - 1] = 0; #endif } sclose(dummy); } return ip; } /* -- end of if2ip() -- */ #else char *Curl_if2ip(const char *interface, char *buf, int buf_size) { (void) interface; (void) buf; (void) buf_size; return NULL; }
/* *保存本端地址 */ int CBaseSocket::SaveSockAddr() { socklen_t len = sizeof(m_SockAddr); int n = getsockname(m_iSocket, (struct sockaddr *)&m_SockAddr, &len); char buf[32] = {0}; inet_ntoa_r(m_SockAddr.sin_addr, buf); return n; }
/* * Get the client's hostname from the transport handle * If the name is not available then return "(anon)". */ void getclientsnames(SVCXPRT *transp, struct netbuf **nbuf, struct nd_hostservlist **serv) { struct netconfig *nconf; char tmp[MAXIPADDRLEN]; char *host = NULL; nconf = getnetconfigent(transp->xp_netid); if (nconf == NULL) { syslog(LOG_ERR, "%s: getnetconfigent failed", transp->xp_netid); *serv = anon_client(host); return; } *nbuf = svc_getrpccaller(transp); if (*nbuf == NULL) { freenetconfigent(nconf); *serv = anon_client(host); return; } /* * Use the this API instead of the netdir_getbyaddr() * to avoid service lookup. */ if (__netdir_getbyaddr_nosrv(nconf, serv, *nbuf)) { host = &tmp[0]; if (strcmp(nconf->nc_protofmly, NC_INET) == 0) { struct sockaddr_in *sa; /* LINTED pointer alignment */ sa = (struct sockaddr_in *)((*nbuf)->buf); (void) inet_ntoa_r(sa->sin_addr, tmp); *serv = anon_client(host); freenetconfigent(nconf); return; } else if (strcmp(nconf->nc_protofmly, NC_INET6) == 0) { struct sockaddr_in6 *sa; /* LINTED pointer alignment */ sa = (struct sockaddr_in6 *)((*nbuf)->buf); (void) inet_ntop(AF_INET6, sa->sin6_addr.s6_addr, tmp, INET6_ADDRSTRLEN); *serv = anon_client(host); freenetconfigent(nconf); return; } freenetconfigent(nconf); *serv = anon_client(host); return; } freenetconfigent(nconf); }
const char * tds_inet_ntoa_r(struct in_addr iaddr, char *ip, size_t len) { #if defined(AF_INET) && HAVE_INET_NTOP inet_ntop(AF_INET, &iaddr, ip, len); #elif HAVE_INET_NTOA_R inet_ntoa_r(iaddr, ip, len); #else tds_strlcpy(ip, inet_ntoa(iaddr), len); #endif return ip; }
void arp_print(struct arp_pkt *arp) { char sha[6*3]; char spa[4*4]; char tha[6*3]; char tpa[4*4]; printf("ARP "); /* switch(arp->arp_h.ar_hrd) { case ARPHRD_ETHER: case ARPHRD_IEEE802: case ARPHRD_ARCNET: case ARPHRD_FRELAY: case ARPHRD_IEEE11394: case ARPHRD_INFINIBAND: default: } */ switch(arp->arp_h.ar_op) { case ARP_OP_REQUEST: printf("Request\n"); break; case ARP_OP_REPLY: printf("Reply\n"); break; case ARP_OP_REVREQUEST: case ARP_OP_REVREPLY: case ARP_OP_INVREQUEST: case ARP_OP_INVREPLY: default: printf("Unknown Operation\n"); } ether_ntoa_r(&arp->sha, sha); inet_ntoa_r(arp->spa, spa, sizeof(spa)); ether_ntoa_r(&arp->tha, tha); inet_ntoa_r(arp->tpa, tpa, sizeof(tpa)); printf(" Sender: %s (%s)\n", spa, sha); printf(" Target: %s (%s)\n", tpa, tha); }
void ip4_print(struct ip4_pkt *ip) { char ip_src[4*4]; char ip_dst[4*4]; uint16_t fragment; printf("IP4\n"); printf(" version: %u\n", ip->ip_h.ip_v); printf(" header len: %u (32bit words)\n", ip->ip_h.ip_hl); printf(" TOS: %" PRIu8 "\n", ip->ip_h.ip_tos); printf(" total len: %hu\n", ntohs(ip->ip_h.ip_len)); printf(" identification: %hu\n", ntohs(ip->ip_h.ip_id)); printf(" fragment flags: "); fragment = ntohs(ip->ip_h.ip_off); printf(" reserved bit: %u ", fragment & IP_RF ? 1 : 0); printf(" DF bit: %u ", fragment & IP_DF ? 1 : 0); printf(" MF bit: %u\n", fragment & IP_MF ? 1 : 0); printf(" fragment offset: %hu\n", (unsigned short)(fragment & IP_OFFMASK)); printf(" TTL: %" PRIu8 "\n", ip->ip_h.ip_ttl); printf(" protocol: "); switch (ip->ip_h.ip_p) { case IPPROTO_TCP: printf("TCP\n"); break; case IPPROTO_UDP: printf("UDP\n"); break; case IPPROTO_ICMP: printf("ICMP\n"); break; default: printf("Unknown Protocol\n"); } printf(" checksum: %hu\n", ntohs(ip->ip_h.ip_sum)); printf(" src IP: %s\n", inet_ntoa_r(ip->ip_h.ip_src, ip_src, sizeof(ip_src))); printf(" dst IP: %s\n", inet_ntoa_r(ip->ip_h.ip_dst, ip_dst, sizeof(ip_dst))); }
void ip4_print_line(struct ip4_pkt *ip) { char ip_src[4*4]; char ip_dst[4*4]; printf("IPv4: %s -> %s ", inet_ntoa_r(ip->ip_h.ip_src, ip_src, sizeof(ip_src)), inet_ntoa_r(ip->ip_h.ip_dst, ip_dst, sizeof(ip_dst))); switch (ip->ip_h.ip_p) { case IPPROTO_TCP: printf("TCP "); break; case IPPROTO_UDP: printf("UDP "); break; case IPPROTO_ICMP: printf("ICMP "); break; default: printf("UNK "); } printf("%u/%hu\n", 4*ip->ip_h.ip_hl, ntohs(ip->ip_h.ip_len)); }
void arp_print_line(struct arp_pkt *arp) { char sha[6*3]; char spa[4*4]; char tha[6*3]; char tpa[4*4]; printf("ARP_"); switch(arp->arp_h.ar_op) { case ARP_OP_REQUEST: printf("REQ"); break; case ARP_OP_REPLY: printf("REP"); break; default: printf("UNK"); } ether_ntoa_r(&arp->sha, sha); inet_ntoa_r(arp->spa, spa, sizeof(spa)); ether_ntoa_r(&arp->tha, tha); inet_ntoa_r(arp->tpa, tpa, sizeof(tpa)); printf(": %s/%s > %s/%s\n", spa, sha, tpa, tha); }
void arp_cache_print(struct arp_cache *arp_cache) { uint32_t i; char ip[4*4]; char mac[6*3]; struct in_addr temp; for (i=0; i < arp_cache->num_entries; i++) { if (arp_cache->values[i].timestamp.tv_sec == 0) continue; temp.s_addr = arp_cache->baseline + htonl(i); inet_ntoa_r(temp, ip, sizeof(ip)); ether_ntoa_r(&arp_cache->values[i].mac, mac); printf("arp_cache[%u]: %s->%s\n", i, ip, mac); } }
int ObProxyCallback::process(easy_request_t *r) { int ret = EASY_OK; if (NULL == r) { TBSYS_LOG(WARN, "request is NULL, r = %p", r); ret = EASY_BREAK; } else if (NULL == r->ipacket) { TBSYS_LOG(WARN, "request is NULL, r->ipacket = %p", r->ipacket); ret = EASY_BREAK; } else { ObProxyServer* server = (ObProxyServer*)r->ms->c->handler->user_data; ObPacket* packet = (ObPacket*)r->ipacket; packet->set_request(r); //handle_request will send response if (OB_REQUIRE_HEARTBEAT == packet->get_packet_code()) { server->handle_request(packet); ret = EASY_OK; } else { ret = server->handlePacket(packet); if (OB_SUCCESS == ret) { r->ms->c->pool->ref++; easy_atomic_inc(&r->ms->pool->ref); easy_pool_set_lock(r->ms->pool); ret = EASY_AGAIN; } else { ret = EASY_OK; TBSYS_LOG(WARN, "can not push packet(src is %s, pcode is %u) to packet queue", inet_ntoa_r(r->ms->c->addr), packet->get_packet_code()); } } } return ret; }
/* Return a numerical IP address and port for the given socket info */ PUBLIC int socketAddress(struct sockaddr *addr, int addrlen, char *ip, int ipLen, int *port) { #if (ME_UNIX_LIKE || WINDOWS) char service[NI_MAXSERV]; #ifdef IN6_IS_ADDR_V4MAPPED if (addr->sa_family == AF_INET6) { struct sockaddr_in6* addr6 = (struct sockaddr_in6*) addr; if (IN6_IS_ADDR_V4MAPPED(&addr6->sin6_addr)) { struct sockaddr_in addr4; memset(&addr4, 0, sizeof(addr4)); addr4.sin_family = AF_INET; addr4.sin_port = addr6->sin6_port; memcpy(&addr4.sin_addr.s_addr, addr6->sin6_addr.s6_addr + 12, sizeof(addr4.sin_addr.s_addr)); memcpy(addr, &addr4, sizeof(addr4)); addrlen = sizeof(addr4); } } #endif if (getnameinfo(addr, addrlen, ip, ipLen, service, sizeof(service), NI_NUMERICHOST | NI_NUMERICSERV | NI_NOFQDN)) { return -1; } if (port) { *port = atoi(service); } #else struct sockaddr_in *sa; #if HAVE_NTOA_R sa = (struct sockaddr_in*) addr; inet_ntoa_r(sa->sin_addr, ip, ipLen); #else uchar *cp; sa = (struct sockaddr_in*) addr; cp = (uchar*) &sa->sin_addr; fmt(ip, ipLen, "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]); #endif if (port) { *port = ntohs(sa->sin_port); } #endif return 0; }
int ObUpdateCallback::process(easy_request_t* r) { int ret = EASY_OK; if (NULL == r) { TBSYS_LOG(ERROR, "request is empty, r = %p", r); ret = EASY_BREAK; } else if (NULL == r->ipacket) { TBSYS_LOG(ERROR, "request is empty, r->ipacket = %p", r->ipacket); ret = EASY_BREAK; } else { ObUpdateServer *server = reinterpret_cast<ObUpdateServer*>(r->ms->c->handler->user_data); ObPacket *req = reinterpret_cast<ObPacket*>(r->ipacket); req->set_request(r); r->ms->c->pool->ref ++; easy_atomic_inc(&r->ms->pool->ref); easy_pool_set_lock(r->ms->pool); ret = server->handlePacket(req); if (OB_SUCCESS == ret) { // enqueue success ret = EASY_AGAIN; } else if (OB_ENQUEUE_FAILED == ret) { TBSYS_LOG(WARN, "can not push packet(src is %s, pcode is %u) to packet queue", inet_ntoa_r(r->ms->c->addr), req->get_packet_code()); r->ms->c->pool->ref --; easy_atomic_dec(&r->ms->pool->ref); ret = EASY_OK; } else /* OB_ERROR */ { ret = EASY_AGAIN; } } return ret; }
static char *MakeIP(unsigned long num,char *addr, int addr_len) { #if defined(HAVE_INET_NTOA) || defined(HAVE_INET_NTOA_R) struct in_addr in; in.s_addr = htonl(num); #if defined(HAVE_INET_NTOA_R) inet_ntoa_r(in,addr,addr_len); #else strncpy(addr,inet_ntoa(in),addr_len); #endif #else unsigned char *paddr; num = htonl(num); /* htonl() added to avoid endian probs */ paddr = (unsigned char *)# sprintf(addr, "%u.%u.%u.%u", paddr[0], paddr[1], paddr[2], paddr[3]); #endif return (addr); }
/* Incomplete implementation, ipv4 only, port does not work, flags do not work */ int tds_getnameinfo(const struct sockaddr *sa, size_t salen, char *host, size_t hostlen, char *serv, size_t servlen, int flags) { struct sockaddr_in *sin = (struct sockaddr_in *) sa; if (sa->sa_family != AF_INET) return EAI_FAMILY; if (host == NULL || hostlen < 16) return EAI_OVERFLOW; #if defined(AF_INET) && HAVE_INET_NTOP inet_ntop(AF_INET, &sin->sin_addr, host, hostlen); #elif HAVE_INET_NTOA_R inet_ntoa_r(sin->sin_addr, host, hostlen); #else strlcpy(hostip, inet_ntoa(sin->sin_addr), hostlen); #endif return 0; }
int rtems_rootfs_append_host_rec (in_addr_t cip, const char *cname, const char *dname) { char buf[128]; char *bufp = buf; const char *bufl[1]; struct in_addr ip; ip.s_addr = cip; if (cname && strlen (cname)) { char addrbuf[INET_ADDRSTRLEN]; snprintf (bufp, sizeof (buf), "%s\t\t%s", inet_ntoa_r (ip, addrbuf), cname); bufp += strlen (buf); if (dname && strlen (dname)) { snprintf (bufp, sizeof (buf), "\t\t%s.%s", cname, dname); bufp += strlen (buf); } strcat (buf, "\n"); bufl[0] = buf; if (rtems_rootfs_file_append ("/etc/hosts", MKFILE_MODE, 1, bufl) < 0) return -1; } else { printf ("rootfs hosts rec append, no cname supplied\n"); return -1; } return 0; }
/* TODO callers seem to set always connection info... change it */ void tds_lookup_host(const char *servername, /* (I) name of the server */ char *ip /* (O) dotted-decimal ip address of server */ ) { /* (O) port number of the service */ struct hostent *host = NULL; unsigned int ip_addr = 0; /* Storage for reentrant getaddrby* calls */ struct hostent result; char buffer[4096]; int h_errnop; /* Only call gethostbyname if servername is not an ip address. * This call take a while and is useless for an ip address. * mlilback 3/2/02 */ ip_addr = inet_addr(servername); if (ip_addr != INADDR_NONE) { strncpy(ip, servername, 17); return; } host = tds_gethostbyname_r(servername, &result, buffer, sizeof(buffer), &h_errnop); ip[0] = '\0'; if (host) { struct in_addr *ptr = (struct in_addr *) host->h_addr; #if defined(AF_INET) && HAVE_INET_NTOP inet_ntop(AF_INET, ptr, ip, 17); #elif HAVE_INET_NTOA_R inet_ntoa_r(*ptr, ip, 17); #else strncpy(ip, inet_ntoa(*ptr), 17); #endif } } /* tds_lookup_host() */
char *inet_ntoa(struct in_addr in) { static pthread_mutex_t inet_ntoa_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_key_t inet_ntoa_key = -1; char *buf, *inet_ntoa_r(); if (inet_ntoa_key < 0) { pthread_mutex_lock(&inet_ntoa_mutex); if (inet_ntoa_key < 0) { if (pthread_key_create(&inet_ntoa_key, free) < 0) { pthread_mutex_unlock(&inet_ntoa_mutex); return(NULL); } } pthread_mutex_unlock(&inet_ntoa_mutex); } if ((buf = pthread_getspecific(inet_ntoa_key)) == NULL) { if ((buf = (char *) malloc(18)) == NULL) { return(NULL); } pthread_setspecific(inet_ntoa_key, buf); } return inet_ntoa_r(in, buf, 18); }
int wifi_cgi(char* buf) { #ifdef DEBUG_CGI printf("\nwificgi -> %s\n", PATH_INFO); #endif char* radio_dhcp; char* radio_static; save_status = html_save_empt; ip_addr_t tmp_ip, tmp_netmask, tmp_gw, tmp_dns1, tmp_dns2; uint8 tmp_dhcp; int buf_cnt = 0; #define WIFI_QUERY_NUM 8 CGI_QUERY wcq[WIFI_QUERY_NUM] = { {"ssid", NULL, "ok"}, {"pswd", NULL, "ok"}, {"dhcp", NULL, "ok"}, {"ip", "000.000.000.001", "ok"}, {"mask", "000.000.000.002", "ok"}, {"gate", "000.000.000.003", "ok"}, {"dns1", "000.000.000.004", "ok"}, {"dns2", "000.000.000.005", "ok"} }; if (QUERY_STRING) { // break query to strings if (cgi_query_scan(QUERY_STRING, wcq, WIFI_QUERY_NUM) == CONN_FAIL) return 0; // convert query strings and check values if ( strlen(wcq[0].valstr)>32 ) {wcq[0].err=html_id_err; save_status = html_save_err;} //SSID if ( strlen(wcq[1].valstr)>32 ) {wcq[1].err=html_id_err; save_status = html_save_err;}//Password if ((strcmp(wcq[2].valstr, "0")) == 0) { radio_dhcp = ""; radio_static = html_checked; tmp_dhcp = 0; } else { if ((strcmp(wcq[2].valstr, "1")) == 0) { radio_dhcp = html_checked; radio_static = ""; tmp_dhcp = 1; } else return 0; } if ( !(inet_aton (wcq[3].valstr, &tmp_ip)) ) {wcq[3].err=html_id_err; save_status = html_save_err;}; //IP if ( !(inet_aton (wcq[4].valstr, &tmp_netmask)) ) {wcq[4].err=html_id_err; save_status = html_save_err;}; //Net mask if ( !(inet_aton (wcq[5].valstr, &tmp_gw)) ) {wcq[5].err=html_id_err; save_status = html_save_err;}; //Gateway if ( !(inet_aton (wcq[6].valstr, &tmp_dns1)) ) {wcq[6].err=html_id_err; save_status = html_save_err;}; //DNS 1 if ( !(inet_aton (wcq[7].valstr, &tmp_dns2)) ) {wcq[7].err=html_id_err; save_status = html_save_err;}; //DNS 2 // if the query values are OK - save to flash if ( save_status != html_save_err ) { if ( wcq[0].valstr[0] != 0 ) // if ssid is not empty {strcpy(sysCfg.sta_ssid, wcq[0].valstr); strcpy(sysCfg.sta_pswd, wcq[1].valstr); } sysCfg.sta_dhcp = tmp_dhcp; sysCfg.sta_ip_info.ip = tmp_ip; sysCfg.sta_ip_info.netmask = tmp_netmask; sysCfg.sta_ip_info.gw = tmp_gw; sysCfg.sta_dns[0] = tmp_dns1; sysCfg.sta_dns[1] = tmp_dns2; CFG_Save(); save_status = html_save_ok; } } // if there was no query or the query was saved succefully // read values from saved config if (save_status != html_save_err) { int ii; // for (ii = 3; ii<WIFI_QUERY_NUM-1; ii++) // wcq[ii].valstr = malloc (16); //read from sysCfg wcq[0].valstr = ""; //SSID wcq[1].valstr = ""; //Password if (sysCfg.sta_dhcp == 0) { radio_dhcp = ""; radio_static = html_checked; } else { radio_dhcp = html_checked; radio_static = ""; } inet_ntoa_r(sysCfg.sta_ip_info.ip, wcq[3].valstr, 16); inet_ntoa_r(sysCfg.sta_ip_info.netmask, wcq[4].valstr, 16); inet_ntoa_r(sysCfg.sta_ip_info.gw, wcq[5].valstr, 16); inet_ntoa_r(sysCfg.sta_dns[0], wcq[6].valstr, 16); inet_ntoa_r(sysCfg.sta_dns[1], wcq[7].valstr, 16); } #ifdef DEBUG_CGI printf ("F**K!!! we are here"); #endif buf_cnt += web_page_header (buf+buf_cnt, wifi_cgi); const char* wifi_cgi_html = "<p><form action=\"wifi.cgi\">" "SSID:\"%s\"<br>" "<p>Change SSID<br>" "(type or choose from list)<br>" "<input list=\"ide\" name=\"ssid\" value=\"%s\" />" "<datalist id=\"ide\">"; buf_cnt += sprintf (buf+buf_cnt, wifi_cgi_html, sysCfg.sta_ssid, wcq[0].valstr); //scanned SSIDs list generation struct bss_info* bss_tmp; while (bss_link) { #ifdef DEBUG_CGI printf ("\n\n ssid p = %p", (void*)bss_link ); printf ("\n\n ssid len = %u", bss_link->ssid_len ); printf ("\n\n ssid = %s", bss_link->ssid ); #endif buf_cnt += sprintf(buf + buf_cnt, "<option value=\"%s\" />", bss_link->ssid); bss_tmp = bss_link; bss_link = bss_link->next.stqe_next; } wifi_cgi_html = "</datalist><a href=/wifi_scan.cgi>SCAN</a><br>" "Password:<br><input type=\"text\" name=\"pswd\" value=\"%s\" ID=\"%s\"></p>" "<p><input type=\"radio\" name=\"dhcp\" value=\"1\" %s> DHCP client<br>" "<input type=\"radio\" name=\"dhcp\" value=\"0\" %s> Static address</p>" "Static - IP:<br><input type=\"text\" name=\"ip\" value=\"%s\" ID=\"%s\" pattern=\"\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\"><br>" "Static - Netmask:<br><input type=\"text\" name=\"mask\" value=\"%s\" ID=\"%s\"><br>" "Static - Gate:<br><input type=\"text\" name=\"gate\" value=\"%s\" ID=\"%s\"><br>" "Static - DNS 1:<br><input type=\"text\" name=\"dns1\" value=\"%s\" ID=\"%s\"><br>" "Static - DNS 2:<br><input type=\"text\" name=\"dns2\" value=\"%s\" ID=\"%s\"><br>" "<br><input type=\"submit\">" "</form>%s" "</body></html>"; buf_cnt += sprintf (buf+buf_cnt, wifi_cgi_html, wcq[1].valstr, wcq[1].err, radio_dhcp, radio_static, wcq[3].valstr, wcq[3].err, wcq[4].valstr, wcq[4].err, wcq[5].valstr, wcq[5].err, wcq[6].valstr, wcq[6].err, wcq[7].valstr, wcq[7].err, save_status ); /* char* valstrs[15]; valstrs[0] = wcq[1].valstr; valstrs[1] = wcq[1].err, valstrs[2] = radio_dhcp; valstrs[3] = radio_static; valstrs[4] = wcq[3].valstr; valstrs[5] = wcq[3].err; valstrs[6] = wcq[4].valstr; valstrs[7] = wcq[4].err; valstrs[8] = wcq[5].valstr; valstrs[9] = wcq[5].err; valstrs[10] = wcq[6].valstr; valstrs[11] = wcq[6].err; valstrs[12] = wcq[7].valstr; valstrs[13] = wcq[7].err; valstrs[14] = save_status; buf_cnt += sssprintf (buf+buf_cnt, wifi_cgi_html, valstrs); */ /* wifi_cgi_html = "</datalist><a href=/wifi_scan.cgi>SCAN</a><br>" "Password:<br><input type=\"text\" name=\"pswd\" value=\"%s\" ID=\"%s\"><br><br>" "<input type=\"radio\" name=\"dhcp\" value=\"1\" %s> DHCP client<br>" "<input type=\"radio\" name=\"dhcp\" value=\"0\" %s> Static address<br>"; buf_cnt += sprintf(buf + buf_cnt, wifi_cgi_html, wcq[1].valstr, wcq[1].err, radio_dhcp, radio_static); wifi_cgi_html = "Static - IP:<br><input type=\"text\" name=\"ip\" value=\"%s\" ID=\"%s\" pattern=\"\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\"><br>" "Static - Netmask:<br><input type=\"text\" name=\"mask\" value=\"%s\" ID=\"%s\"><br>" "Static - Gate:<br><input type=\"text\" name=\"gate\" value=\"%s\" ID=\"%s\"><br>"; buf_cnt += sprintf(buf + buf_cnt, wifi_cgi_html, wcq[3].valstr, wcq[3].err, wcq[4].valstr, wcq[4].err, wcq[5].valstr, wcq[5].err); wifi_cgi_html = "Static - DNS 1:<br><input type=\"text\" name=\"dns1\" value=\"%s\" ID=\"%s\"><br>" "Static - DNS 2:<br><input type=\"text\" name=\"dns2\" value=\"%s\" ID=\"%s\"><br>" "<br><input type=\"submit\">" "</form>%s" "</body></html>"; buf_cnt += sprintf(buf + buf_cnt, wifi_cgi_html,wcq[6].valstr, wcq[6].err, wcq[7].valstr, wcq[7].err, save_status ); */ buf_cnt += web_page_footer (buf+buf_cnt, wifi_cgi); return buf_cnt; }
/** * Install state of type 'type' for a dynamic session. * The hash table contains two type of rules: * - regular rules (O_KEEP_STATE) * - rules for sessions with limited number of sess per user * (O_LIMIT). When they are created, the parent is * increased by 1, and decreased on delete. In this case, * the third parameter is the parent rule and not the chain. * - "parent" rules for the above (O_LIMIT_PARENT). */ static ipfw_dyn_rule * add_dyn_rule(struct ipfw_flow_id *id, u_int8_t dyn_type, struct ip_fw *rule) { ipfw_dyn_rule *r; int i; IPFW_DYN_LOCK_ASSERT(); if (V_ipfw_dyn_v == NULL || (V_dyn_count == 0 && V_dyn_buckets != V_curr_dyn_buckets)) { realloc_dynamic_table(); if (V_ipfw_dyn_v == NULL) return NULL; /* failed ! */ } i = hash_packet(id); r = uma_zalloc(ipfw_dyn_rule_zone, M_NOWAIT | M_ZERO); if (r == NULL) { printf ("ipfw: sorry cannot allocate state\n"); return NULL; } /* increase refcount on parent, and set pointer */ if (dyn_type == O_LIMIT) { ipfw_dyn_rule *parent = (ipfw_dyn_rule *)rule; if ( parent->dyn_type != O_LIMIT_PARENT) panic("invalid parent"); parent->count++; r->parent = parent; rule = parent->rule; } r->id = *id; r->expire = time_uptime + V_dyn_syn_lifetime; r->rule = rule; r->dyn_type = dyn_type; r->pcnt = r->bcnt = 0; r->count = 0; r->bucket = i; r->next = V_ipfw_dyn_v[i]; V_ipfw_dyn_v[i] = r; V_dyn_count++; DEB({ struct in_addr da; #ifdef INET6 char src[INET6_ADDRSTRLEN]; char dst[INET6_ADDRSTRLEN]; #else char src[INET_ADDRSTRLEN]; char dst[INET_ADDRSTRLEN]; #endif #ifdef INET6 if (IS_IP6_FLOW_ID(&(r->id))) { ip6_sprintf(src, &r->id.src_ip6); ip6_sprintf(dst, &r->id.dst_ip6); } else #endif { da.s_addr = htonl(r->id.src_ip); inet_ntoa_r(da, src); da.s_addr = htonl(r->id.dst_ip); inet_ntoa_r(da, dst); } printf("ipfw: add dyn entry ty %d %s %d -> %s %d, total %d\n", dyn_type, src, r->id.src_port, dst, r->id.dst_port, V_dyn_count); }) return r;
/* * We enter here when we have a rule with O_LOG. * XXX this function alone takes about 2Kbytes of code! */ void ipfw_log(struct ip_fw_chain *chain, struct ip_fw *f, u_int hlen, struct ip_fw_args *args, struct mbuf *m, struct ifnet *oif, u_short offset, uint32_t tablearg, struct ip *ip) { char *action; int limit_reached = 0; char action2[92], proto[128], fragment[32]; if (V_fw_verbose == 0) { if (args->eh) /* layer2, use orig hdr */ ipfw_bpf_mtap2(args->eh, ETHER_HDR_LEN, m); else { /* Add fake header. Later we will store * more info in the header. */ if (ip->ip_v == 4) ipfw_bpf_mtap2("DDDDDDSSSSSS\x08\x00", ETHER_HDR_LEN, m); else if (ip->ip_v == 6) ipfw_bpf_mtap2("DDDDDDSSSSSS\x86\xdd", ETHER_HDR_LEN, m); else /* Obviously bogus EtherType. */ ipfw_bpf_mtap2("DDDDDDSSSSSS\xff\xff", ETHER_HDR_LEN, m); } return; } /* the old 'log' function */ fragment[0] = '\0'; proto[0] = '\0'; if (f == NULL) { /* bogus pkt */ if (V_verbose_limit != 0 && V_norule_counter >= V_verbose_limit) return; V_norule_counter++; if (V_norule_counter == V_verbose_limit) limit_reached = V_verbose_limit; action = "Refuse"; } else { /* O_LOG is the first action, find the real one */ ipfw_insn *cmd = ACTION_PTR(f); ipfw_insn_log *l = (ipfw_insn_log *)cmd; if (l->max_log != 0 && l->log_left == 0) return; l->log_left--; if (l->log_left == 0) limit_reached = l->max_log; cmd += F_LEN(cmd); /* point to first action */ if (cmd->opcode == O_ALTQ) { ipfw_insn_altq *altq = (ipfw_insn_altq *)cmd; snprintf(SNPARGS(action2, 0), "Altq %d", altq->qid); cmd += F_LEN(cmd); } if (cmd->opcode == O_PROB || cmd->opcode == O_TAG || cmd->opcode == O_SETDSCP) cmd += F_LEN(cmd); action = action2; switch (cmd->opcode) { case O_DENY: action = "Deny"; break; case O_REJECT: if (cmd->arg1==ICMP_REJECT_RST) action = "Reset"; else if (cmd->arg1==ICMP_REJECT_ABORT) action = "Abort"; else if (cmd->arg1==ICMP_UNREACH_HOST) action = "Reject"; else snprintf(SNPARGS(action2, 0), "Unreach %d", cmd->arg1); break; case O_UNREACH6: if (cmd->arg1==ICMP6_UNREACH_RST) action = "Reset"; else if (cmd->arg1==ICMP6_UNREACH_ABORT) action = "Abort"; else snprintf(SNPARGS(action2, 0), "Unreach %d", cmd->arg1); break; case O_ACCEPT: action = "Accept"; break; case O_COUNT: action = "Count"; break; case O_DIVERT: snprintf(SNPARGS(action2, 0), "Divert %d", TARG(cmd->arg1, divert)); break; case O_TEE: snprintf(SNPARGS(action2, 0), "Tee %d", TARG(cmd->arg1, divert)); break; case O_SETFIB: snprintf(SNPARGS(action2, 0), "SetFib %d", TARG(cmd->arg1, fib) & 0x7FFF); break; case O_SKIPTO: snprintf(SNPARGS(action2, 0), "SkipTo %d", TARG(cmd->arg1, skipto)); break; case O_PIPE: snprintf(SNPARGS(action2, 0), "Pipe %d", TARG(cmd->arg1, pipe)); break; case O_QUEUE: snprintf(SNPARGS(action2, 0), "Queue %d", TARG(cmd->arg1, pipe)); break; case O_FORWARD_IP: { char buf[INET_ADDRSTRLEN]; ipfw_insn_sa *sa = (ipfw_insn_sa *)cmd; int len; struct in_addr dummyaddr; if (sa->sa.sin_addr.s_addr == INADDR_ANY) dummyaddr.s_addr = htonl(tablearg); else dummyaddr.s_addr = sa->sa.sin_addr.s_addr; len = snprintf(SNPARGS(action2, 0), "Forward to %s", inet_ntoa_r(dummyaddr, buf)); if (sa->sa.sin_port) snprintf(SNPARGS(action2, len), ":%d", sa->sa.sin_port); } break; #ifdef INET6 case O_FORWARD_IP6: { char buf[INET6_ADDRSTRLEN]; ipfw_insn_sa6 *sa = (ipfw_insn_sa6 *)cmd; int len; len = snprintf(SNPARGS(action2, 0), "Forward to [%s]", ip6_sprintf(buf, &sa->sa.sin6_addr)); if (sa->sa.sin6_port) snprintf(SNPARGS(action2, len), ":%u", sa->sa.sin6_port); } break; #endif case O_NETGRAPH: snprintf(SNPARGS(action2, 0), "Netgraph %d", cmd->arg1); break; case O_NGTEE: snprintf(SNPARGS(action2, 0), "Ngtee %d", cmd->arg1); break; case O_NAT: action = "Nat"; break; case O_REASS: action = "Reass"; break; case O_CALLRETURN: if (cmd->len & F_NOT) action = "Return"; else snprintf(SNPARGS(action2, 0), "Call %d", cmd->arg1); break; case O_EXTERNAL_ACTION: snprintf(SNPARGS(action2, 0), "Eaction %s", ((struct named_object *)SRV_OBJECT(chain, cmd->arg1))->name); break; default: action = "UNKNOWN"; break; } } if (hlen == 0) { /* non-ip */ snprintf(SNPARGS(proto, 0), "MAC"); } else { int len; #ifdef INET6 char src[INET6_ADDRSTRLEN + 2], dst[INET6_ADDRSTRLEN + 2]; #else char src[INET_ADDRSTRLEN], dst[INET_ADDRSTRLEN]; #endif struct icmphdr *icmp; struct tcphdr *tcp; struct udphdr *udp; #ifdef INET6 struct ip6_hdr *ip6 = NULL; struct icmp6_hdr *icmp6; u_short ip6f_mf; #endif src[0] = '\0'; dst[0] = '\0'; #ifdef INET6 ip6f_mf = offset & IP6F_MORE_FRAG; offset &= IP6F_OFF_MASK; if (IS_IP6_FLOW_ID(&(args->f_id))) { char ip6buf[INET6_ADDRSTRLEN]; snprintf(src, sizeof(src), "[%s]", ip6_sprintf(ip6buf, &args->f_id.src_ip6)); snprintf(dst, sizeof(dst), "[%s]", ip6_sprintf(ip6buf, &args->f_id.dst_ip6)); ip6 = (struct ip6_hdr *)ip; tcp = (struct tcphdr *)(((char *)ip) + hlen); udp = (struct udphdr *)(((char *)ip) + hlen); } else #endif { tcp = L3HDR(struct tcphdr, ip); udp = L3HDR(struct udphdr, ip); inet_ntop(AF_INET, &ip->ip_src, src, sizeof(src)); inet_ntop(AF_INET, &ip->ip_dst, dst, sizeof(dst)); } switch (args->f_id.proto) { case IPPROTO_TCP: len = snprintf(SNPARGS(proto, 0), "TCP %s", src); if (offset == 0) snprintf(SNPARGS(proto, len), ":%d %s:%d", ntohs(tcp->th_sport), dst, ntohs(tcp->th_dport)); else snprintf(SNPARGS(proto, len), " %s", dst); break; case IPPROTO_UDP: case IPPROTO_UDPLITE: len = snprintf(SNPARGS(proto, 0), "UDP%s%s", args->f_id.proto == IPPROTO_UDP ? " ": "Lite ", src); if (offset == 0) snprintf(SNPARGS(proto, len), ":%d %s:%d", ntohs(udp->uh_sport), dst, ntohs(udp->uh_dport)); else snprintf(SNPARGS(proto, len), " %s", dst); break; case IPPROTO_ICMP: icmp = L3HDR(struct icmphdr, ip); if (offset == 0) len = snprintf(SNPARGS(proto, 0), "ICMP:%u.%u ", icmp->icmp_type, icmp->icmp_code); else len = snprintf(SNPARGS(proto, 0), "ICMP "); len += snprintf(SNPARGS(proto, len), "%s", src); snprintf(SNPARGS(proto, len), " %s", dst); break; #ifdef INET6 case IPPROTO_ICMPV6: icmp6 = (struct icmp6_hdr *)(((char *)ip) + hlen); if (offset == 0) len = snprintf(SNPARGS(proto, 0), "ICMPv6:%u.%u ", icmp6->icmp6_type, icmp6->icmp6_code); else len = snprintf(SNPARGS(proto, 0), "ICMPv6 "); len += snprintf(SNPARGS(proto, len), "%s", src); snprintf(SNPARGS(proto, len), " %s", dst); break; #endif default: len = snprintf(SNPARGS(proto, 0), "P:%d %s", args->f_id.proto, src); snprintf(SNPARGS(proto, len), " %s", dst); break; } #ifdef INET6 if (IS_IP6_FLOW_ID(&(args->f_id))) { if (offset || ip6f_mf) snprintf(SNPARGS(fragment, 0), " (frag %08x:%d@%d%s)", args->f_id.extra, ntohs(ip6->ip6_plen) - hlen, ntohs(offset) << 3, ip6f_mf ? "+" : ""); } else #endif { int ipoff, iplen; ipoff = ntohs(ip->ip_off); iplen = ntohs(ip->ip_len); if (ipoff & (IP_MF | IP_OFFMASK)) snprintf(SNPARGS(fragment, 0), " (frag %d:%d@%d%s)", ntohs(ip->ip_id), iplen - (ip->ip_hl << 2), offset << 3, (ipoff & IP_MF) ? "+" : ""); } } #ifdef __FreeBSD__ if (oif || m->m_pkthdr.rcvif) log(LOG_SECURITY | LOG_INFO, "ipfw: %d %s %s %s via %s%s\n", f ? f->rulenum : -1, action, proto, oif ? "out" : "in", oif ? oif->if_xname : m->m_pkthdr.rcvif->if_xname, fragment); else #endif log(LOG_SECURITY | LOG_INFO, "ipfw: %d %s %s [no if info]%s\n", f ? f->rulenum : -1, action, proto, fragment); if (limit_reached) log(LOG_SECURITY | LOG_NOTICE, "ipfw: limit %d reached on entry %d\n", limit_reached, f ? f->rulenum : -1); }
int CBaseSocket::Connect(struct sockaddr_in *addr, int timeout_usec /*=-1*/) { char buf[32] = {0}; inet_ntoa_r(addr->sin_addr, buf); socklen_t addr_len = sizeof(struct sockaddr_in); int retval = 0; if (timeout_usec < 0) // 阻塞 { int n = connect(m_iSocket, (struct sockaddr *)addr, addr_len); if(n != 0) { perror("connect:"); return -1; } //........... SaveAddr(); return 0; } SetNonBlockOption(true); retval= connect(m_iSocket, (struct sockaddr *) addr, addr_len); if(retval < 0 && errno != EINPROGRESS) { Close(); return -1; } if(retval == 0) { SaveAddr(); SetNonBlockOption(false); return 0; } if(timeout_usec == 0) //timeout { Close(); return -1; } fd_set rset, wset; FD_ZERO(&rset); FD_SET(m_iSocket, &rset); FD_ZERO(&wset); FD_SET(m_iSocket, &wset); struct timeval timeout; MkTimeval(timeout, timeout_usec); int n = select(m_iSocket + 1, &rset, &wset, NULL, &timeout); if( n == 0) //timeout { Close(); return -1; } int error = 0; if(FD_ISSET(m_iSocket, &rset) || FD_ISSET(m_iSocket, &wset)) { socklen_t len = sizeof(error); if(getsockopt(m_iSocket, SOL_SOCKET, SO_ERROR, &error, &len) < 0) { Close(); return -1; } SetNonBlockOption(false); if(error) { Close(); return -1; } SaveAddr(); return 0; } //not ready... Close(); return -1; }
/* * We enter here when we have a rule with O_LOG. * XXX this function alone takes about 2Kbytes of code! */ void ipfw_log(struct ip_fw *f, u_int hlen, struct ip_fw_args *args, struct mbuf *m, struct ifnet *oif, u_short offset, uint32_t tablearg, struct ip *ip) { char *action; int limit_reached = 0; char action2[40], proto[128], fragment[32]; if (V_fw_verbose == 0) { #ifndef WITHOUT_BPF struct m_hdr mh; if (log_if == NULL || log_if->if_bpf == NULL) return; /* BPF treats the "mbuf" as read-only */ mh.mh_next = m; mh.mh_len = ETHER_HDR_LEN; if (args->eh) { /* layer2, use orig hdr */ mh.mh_data = (char *)args->eh; } else { /* add fake header. Later we will store * more info in the header */ mh.mh_data = "DDDDDDSSSSSS\x08\x00"; } BPF_MTAP(log_if, (struct mbuf *)&mh); #endif /* !WITHOUT_BPF */ return; } /* the old 'log' function */ fragment[0] = '\0'; proto[0] = '\0'; if (f == NULL) { /* bogus pkt */ if (V_verbose_limit != 0 && V_norule_counter >= V_verbose_limit) return; V_norule_counter++; if (V_norule_counter == V_verbose_limit) limit_reached = V_verbose_limit; action = "Refuse"; } else { /* O_LOG is the first action, find the real one */ ipfw_insn *cmd = ACTION_PTR(f); ipfw_insn_log *l = (ipfw_insn_log *)cmd; if (l->max_log != 0 && l->log_left == 0) return; l->log_left--; if (l->log_left == 0) limit_reached = l->max_log; cmd += F_LEN(cmd); /* point to first action */ if (cmd->opcode == O_ALTQ) { ipfw_insn_altq *altq = (ipfw_insn_altq *)cmd; snprintf(SNPARGS(action2, 0), "Altq %d", altq->qid); cmd += F_LEN(cmd); } if (cmd->opcode == O_PROB) cmd += F_LEN(cmd); if (cmd->opcode == O_TAG) cmd += F_LEN(cmd); action = action2; switch (cmd->opcode) { case O_DENY: action = "Deny"; break; case O_REJECT: if (cmd->arg1==ICMP_REJECT_RST) action = "Reset"; else if (cmd->arg1==ICMP_UNREACH_HOST) action = "Reject"; else snprintf(SNPARGS(action2, 0), "Unreach %d", cmd->arg1); break; case O_UNREACH6: if (cmd->arg1==ICMP6_UNREACH_RST) action = "Reset"; else snprintf(SNPARGS(action2, 0), "Unreach %d", cmd->arg1); break; case O_ACCEPT: action = "Accept"; break; case O_COUNT: action = "Count"; break; case O_DIVERT: snprintf(SNPARGS(action2, 0), "Divert %d", cmd->arg1); break; case O_TEE: snprintf(SNPARGS(action2, 0), "Tee %d", cmd->arg1); break; case O_SETFIB: snprintf(SNPARGS(action2, 0), "SetFib %d", cmd->arg1); break; case O_SKIPTO: snprintf(SNPARGS(action2, 0), "SkipTo %d", cmd->arg1); break; case O_PIPE: snprintf(SNPARGS(action2, 0), "Pipe %d", cmd->arg1); break; case O_QUEUE: snprintf(SNPARGS(action2, 0), "Queue %d", cmd->arg1); break; case O_FORWARD_IP: { ipfw_insn_sa *sa = (ipfw_insn_sa *)cmd; int len; struct in_addr dummyaddr; if (sa->sa.sin_addr.s_addr == INADDR_ANY) dummyaddr.s_addr = htonl(tablearg); else dummyaddr.s_addr = sa->sa.sin_addr.s_addr; len = snprintf(SNPARGS(action2, 0), "Forward to %s", inet_ntoa(dummyaddr)); if (sa->sa.sin_port) snprintf(SNPARGS(action2, len), ":%d", sa->sa.sin_port); } break; case O_NETGRAPH: snprintf(SNPARGS(action2, 0), "Netgraph %d", cmd->arg1); break; case O_NGTEE: snprintf(SNPARGS(action2, 0), "Ngtee %d", cmd->arg1); break; case O_NAT: action = "Nat"; break; case O_REASS: action = "Reass"; break; default: action = "UNKNOWN"; break; } } if (hlen == 0) { /* non-ip */ snprintf(SNPARGS(proto, 0), "MAC"); } else { int len; #ifdef INET6 char src[INET6_ADDRSTRLEN + 2], dst[INET6_ADDRSTRLEN + 2]; #else char src[INET_ADDRSTRLEN], dst[INET_ADDRSTRLEN]; #endif struct icmphdr *icmp; struct tcphdr *tcp; struct udphdr *udp; #ifdef INET6 struct ip6_hdr *ip6 = NULL; struct icmp6_hdr *icmp6; #endif src[0] = '\0'; dst[0] = '\0'; #ifdef INET6 if (IS_IP6_FLOW_ID(&(args->f_id))) { char ip6buf[INET6_ADDRSTRLEN]; snprintf(src, sizeof(src), "[%s]", ip6_sprintf(ip6buf, &args->f_id.src_ip6)); snprintf(dst, sizeof(dst), "[%s]", ip6_sprintf(ip6buf, &args->f_id.dst_ip6)); ip6 = (struct ip6_hdr *)ip; tcp = (struct tcphdr *)(((char *)ip) + hlen); udp = (struct udphdr *)(((char *)ip) + hlen); } else #endif { tcp = L3HDR(struct tcphdr, ip); udp = L3HDR(struct udphdr, ip); inet_ntoa_r(ip->ip_src, src); inet_ntoa_r(ip->ip_dst, dst); } switch (args->f_id.proto) { case IPPROTO_TCP: len = snprintf(SNPARGS(proto, 0), "TCP %s", src); if (offset == 0) snprintf(SNPARGS(proto, len), ":%d %s:%d", ntohs(tcp->th_sport), dst, ntohs(tcp->th_dport)); else snprintf(SNPARGS(proto, len), " %s", dst); break; case IPPROTO_UDP: len = snprintf(SNPARGS(proto, 0), "UDP %s", src); if (offset == 0) snprintf(SNPARGS(proto, len), ":%d %s:%d", ntohs(udp->uh_sport), dst, ntohs(udp->uh_dport)); else snprintf(SNPARGS(proto, len), " %s", dst); break; case IPPROTO_ICMP: icmp = L3HDR(struct icmphdr, ip); if (offset == 0) len = snprintf(SNPARGS(proto, 0), "ICMP:%u.%u ", icmp->icmp_type, icmp->icmp_code); else len = snprintf(SNPARGS(proto, 0), "ICMP "); len += snprintf(SNPARGS(proto, len), "%s", src); snprintf(SNPARGS(proto, len), " %s", dst); break; #ifdef INET6 case IPPROTO_ICMPV6: icmp6 = (struct icmp6_hdr *)(((char *)ip) + hlen); if (offset == 0) len = snprintf(SNPARGS(proto, 0), "ICMPv6:%u.%u ", icmp6->icmp6_type, icmp6->icmp6_code); else len = snprintf(SNPARGS(proto, 0), "ICMPv6 "); len += snprintf(SNPARGS(proto, len), "%s", src); snprintf(SNPARGS(proto, len), " %s", dst); break; #endif default: len = snprintf(SNPARGS(proto, 0), "P:%d %s", args->f_id.proto, src); snprintf(SNPARGS(proto, len), " %s", dst); break; } #ifdef INET6 if (IS_IP6_FLOW_ID(&(args->f_id))) { if (offset & (IP6F_OFF_MASK | IP6F_MORE_FRAG)) snprintf(SNPARGS(fragment, 0), " (frag %08x:%d@%d%s)", args->f_id.extra, ntohs(ip6->ip6_plen) - hlen, ntohs(offset & IP6F_OFF_MASK) << 3, (offset & IP6F_MORE_FRAG) ? "+" : ""); } else #endif { int ipoff, iplen; ipoff = ntohs(ip->ip_off); iplen = ntohs(ip->ip_len); if (ipoff & (IP_MF | IP_OFFMASK)) snprintf(SNPARGS(fragment, 0), " (frag %d:%d@%d%s)", ntohs(ip->ip_id), iplen - (ip->ip_hl << 2), offset << 3, (ipoff & IP_MF) ? "+" : ""); } } #ifdef __FreeBSD__ if (oif || m->m_pkthdr.rcvif) log(LOG_SECURITY | LOG_INFO, "ipfw: %d %s %s %s via %s%s\n", f ? f->rulenum : -1, action, proto, oif ? "out" : "in", oif ? oif->if_xname : m->m_pkthdr.rcvif->if_xname, fragment); else #endif log(LOG_SECURITY | LOG_INFO, "ipfw: %d %s %s [no if info]%s\n", f ? f->rulenum : -1, action, proto, fragment); if (limit_reached) log(LOG_SECURITY | LOG_NOTICE, "ipfw: limit %d reached on entry %d\n", limit_reached, f ? f->rulenum : -1); }
static void tcp_server_task(void *pvParameters) { char rx_buffer[128]; char addr_str[128]; int addr_family; int ip_protocol; while (1) { #ifdef CONFIG_EXAMPLE_IPV4 struct sockaddr_in destAddr; destAddr.sin_addr.s_addr = htonl(INADDR_ANY); destAddr.sin_family = AF_INET; destAddr.sin_port = htons(PORT); addr_family = AF_INET; ip_protocol = IPPROTO_IP; inet_ntoa_r(destAddr.sin_addr, addr_str, sizeof(addr_str) - 1); #else // IPV6 struct sockaddr_in6 destAddr; bzero(&destAddr.sin6_addr.un, sizeof(destAddr.sin6_addr.un)); destAddr.sin6_family = AF_INET6; destAddr.sin6_port = htons(PORT); addr_family = AF_INET6; ip_protocol = IPPROTO_IPV6; inet6_ntoa_r(destAddr.sin6_addr, addr_str, sizeof(addr_str) - 1); #endif int listen_sock = socket(addr_family, SOCK_STREAM, ip_protocol); if (listen_sock < 0) { ESP_LOGE(TAG, "Unable to create socket: errno %d", errno); break; } ESP_LOGI(TAG, "Socket created"); int err = bind(listen_sock, (struct sockaddr *)&destAddr, sizeof(destAddr)); if (err != 0) { ESP_LOGE(TAG, "Socket unable to bind: errno %d", errno); break; } ESP_LOGI(TAG, "Socket binded"); err = listen(listen_sock, 1); if (err != 0) { ESP_LOGE(TAG, "Error occured during listen: errno %d", errno); break; } ESP_LOGI(TAG, "Socket listening"); #ifdef CONFIG_EXAMPLE_IPV6 struct sockaddr_in6 sourceAddr; // Large enough for both IPv4 or IPv6 #else struct sockaddr_in sourceAddr; #endif uint addrLen = sizeof(sourceAddr); int sock = accept(listen_sock, (struct sockaddr *)&sourceAddr, &addrLen); if (sock < 0) { ESP_LOGE(TAG, "Unable to accept connection: errno %d", errno); break; } ESP_LOGI(TAG, "Socket accepted"); while (1) { int len = recv(sock, rx_buffer, sizeof(rx_buffer) - 1, 0); // Error occured during receiving if (len < 0) { ESP_LOGE(TAG, "recv failed: errno %d", errno); break; } // Connection closed else if (len == 0) { ESP_LOGI(TAG, "Connection closed"); break; } // Data received else { #ifdef CONFIG_EXAMPLE_IPV6 // Get the sender's ip address as string if (sourceAddr.sin6_family == PF_INET) { inet_ntoa_r(((struct sockaddr_in *)&sourceAddr)->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1); } else if (sourceAddr.sin6_family == PF_INET6) { inet6_ntoa_r(sourceAddr.sin6_addr, addr_str, sizeof(addr_str) - 1); } #else inet_ntoa_r(((struct sockaddr_in *)&sourceAddr)->sin_addr.s_addr, addr_str, sizeof(addr_str) - 1); #endif rx_buffer[len] = 0; // Null-terminate whatever we received and treat like a string ESP_LOGI(TAG, "Received %d bytes from %s:", len, addr_str); ESP_LOGI(TAG, "%s", rx_buffer); int err = send(sock, rx_buffer, len, 0); if (err < 0) { ESP_LOGE(TAG, "Error occured during sending: errno %d", errno); break; } } } if (sock != -1) { ESP_LOGE(TAG, "Shutting down socket and restarting..."); shutdown(sock, 0); close(sock); } } vTaskDelete(NULL); }
static int AliasHandleUdpNbt( struct libalias *la, struct ip *pip, /* IP packet to examine/patch */ struct alias_link *lnk, struct in_addr *alias_address, u_short alias_port ) { struct udphdr *uh; NbtDataHeader *ndh; u_char *p = NULL; char *pmax; #ifdef LIBALIAS_DEBUG char addrbuf[INET_ADDRSTRLEN]; #endif (void)la; (void)lnk; /* Calculate data length of UDP packet */ uh = (struct udphdr *)ip_next(pip); pmax = (char *)uh + ntohs(uh->uh_ulen); ndh = (NbtDataHeader *)udp_next(uh); if ((char *)(ndh + 1) > pmax) return (-1); #ifdef LIBALIAS_DEBUG printf("\nType=%02x,", ndh->type); #endif switch (ndh->type) { case DGM_DIRECT_UNIQ: case DGM_DIRECT_GROUP: case DGM_BROADCAST: p = (u_char *) ndh + 14; p = AliasHandleName(p, pmax); /* Source Name */ p = AliasHandleName(p, pmax); /* Destination Name */ break; case DGM_ERROR: p = (u_char *) ndh + 11; break; case DGM_QUERY: case DGM_POSITIVE_RES: case DGM_NEGATIVE_RES: p = (u_char *) ndh + 10; p = AliasHandleName(p, pmax); /* Destination Name */ break; } if (p == NULL || (char *)p > pmax) p = NULL; #ifdef LIBALIAS_DEBUG printf("%s:%d-->", inet_ntoa_r(ndh->source_ip, INET_NTOA_BUF(addrbuf)), ntohs(ndh->source_port)); #endif /* Doing an IP address and Port number Translation */ if (uh->uh_sum != 0) { int acc; u_short *sptr; acc = ndh->source_port; acc -= alias_port; sptr = (u_short *) & (ndh->source_ip); acc += *sptr++; acc += *sptr; sptr = (u_short *) alias_address; acc -= *sptr++; acc -= *sptr; ADJUST_CHECKSUM(acc, uh->uh_sum); } ndh->source_ip = *alias_address; ndh->source_port = alias_port; #ifdef LIBALIAS_DEBUG printf("%s:%d\n", inet_ntoa_r(ndh->source_ip, INET_NTOA_BUF(addrbuf)), ntohs(ndh->source_port)); fflush(stdout); #endif return ((p == NULL) ? -1 : 0); }
/* * XXX: will not work correctly with IPv6 extension headers */ static void log_packet(struct mbuf **mb, userfw_chk_args *args, userfw_action *a, userfw_cache *cache) { char *dir = (args->dir == USERFW_IN) ? "in" : "out"; char *proto, *ipproto; struct ip *ip = mtod(*mb, struct ip *); struct ip6_hdr *ip6 = mtod(*mb, struct ip6_hdr *); struct tcphdr *tcp = NULL; struct udphdr *udp = NULL; struct sctphdr *sctp = NULL; char action[USERFW_NAME_LEN+1] = {0}; char src[64] = {0}; char dst[64] = {0}; char iface[IFNAMSIZ+1] = "UNKNOWN"; int l4proto = -1; char ipproto_buf[4] = {0}; char portbuf[16] = {0}; uint16_t srcport, dstport; int have_ports = 0; switch(ip->ip_v) { case 4: proto = "IPv4"; l4proto = ip->ip_p; inet_ntoa_r(ip->ip_src, src); inet_ntoa_r(ip->ip_dst, dst); tcp = L3HDR(struct tcphdr, ip); udp = L3HDR(struct udphdr, ip); sctp = L3HDR(struct sctphdr, ip); break; case 6: proto = "IPv6"; l4proto = ip6->ip6_nxt; char buf[INET6_ADDRSTRLEN]; snprintf(src, sizeof(src), "[%s]", ip6_sprintf(buf, &(ip6->ip6_src))); snprintf(dst, sizeof(dst), "[%s]", ip6_sprintf(buf, &(ip6->ip6_dst))); tcp = (struct tcphdr *)(((char *)ip6) + sizeof(struct ip6_hdr)); udp = (struct udphdr *)(((char *)ip6) + sizeof(struct ip6_hdr)); sctp = (struct sctphdr *)(((char *)ip6) + sizeof(struct ip6_hdr)); break; default: proto = "UNKNOWN_L3"; break; } switch(l4proto) { case -1: ipproto = "UNKNOWN_L4"; break; case IPPROTO_TCP: ipproto = "TCP"; srcport = tcp->th_sport; dstport = tcp->th_dport; have_ports = 1; break; case IPPROTO_UDP: ipproto = "UDP"; srcport = udp->uh_sport; dstport = udp->uh_dport; have_ports = 1; break; case IPPROTO_SCTP: ipproto = "SCTP"; srcport = sctp->src_port; dstport = sctp->dest_port; have_ports = 1; break; case IPPROTO_ICMP: ipproto = "ICMP"; break; default: sprintf(ipproto_buf, "%d", l4proto & 0xff); ipproto = ipproto_buf; break; } if (have_ports) { snprintf(portbuf, sizeof(portbuf), ":%u", ntohs(srcport)); strlcat(src, portbuf, sizeof(src)); snprintf(portbuf, sizeof(portbuf), ":%u", ntohs(dstport)); strlcat(dst, portbuf, sizeof(dst)); } if (args->ifp != NULL) { bcopy(args->ifp->if_xname, iface, IFNAMSIZ); } if (a != NULL) { const userfw_action_descr *descr = userfw_mod_find_action(a->mod, a->op); if (descr != NULL) { bcopy(descr->name, action, USERFW_NAME_LEN); } } log(LOG_SECURITY | LOG_INFO, "userfw: %s %s %s %s %s %s via %s\n", action, proto, ipproto, src, dst, dir, iface); }