/** * Determine if two address are on the same network. * * @arg addr1 IP address 1 * @arg addr2 IP address 2 * @arg mask network identifier mask * @return !0 if the network identifiers of both address match */ public static bool ip_addr_netcmp(ip_addr addr1, ip_addr addr2, ip_addr mask) { return(((addr1).addr & (mask).addr) == ((addr2).addr & (mask).addr)); }
public const int IP_LOOPBACKNET = 127; /* official! */ /** Set an IP address given by the four byte-parts. * Little-endian version that prevents the use of lwip.lwip_htonl. */ public static void IP4_ADDR(ip_addr ipaddr, byte a, byte b, byte c, byte d) { ipaddr.addr = ((uint)((d) & 0xff) << 24) | ((uint)((c) & 0xff) << 16) | ((uint)((b) & 0xff) << 8) | (uint)((a) & 0xff); }
internal err_t output(lwip ip, pbuf p, ip_addr src, ip_addr dest, byte ttl, byte tos, byte proto) { int pos = 0, rest = p.tot_len; byte[] packet = new byte[rest]; ip_addr srch = new ip_addr(lwip_ntohl(src.addr)); ip_addr desth = new ip_addr(lwip_ntohl(dest.addr)); for (pbuf q = p; q != null; q = q.next) { int len = rest; if (len > q.len) { len = q.len; } Buffer.BlockCopy(q.payload.data, q.payload.offset, packet, pos, len); pos += len; rest -= len; } m_output(ip, packet, srch, desth, proto); return(err_t.ERR_OK); }
internal void input(pointer packet, int length, ip_addr srcn, ip_addr destn, byte proto) { ip_addr src = new ip_addr(lwip.lwip_htonl(srcn.addr)); ip_addr dest = new ip_addr(lwip.lwip_htonl(destn.addr)); pbuf p = pbuf_alloc(pbuf_layer.PBUF_RAW, (ushort)length, pbuf_type.PBUF_POOL); int pos = 0, rest = length; for (pbuf q = p; q != null; q = q.next) { int len = rest; if (len > q.len) { len = q.len; } pointer.memcpy(q.payload, new pointer(packet, pos), len); pos += len; rest -= len; } if (ip_input(p, src, dest, proto) != err_t.ERR_OK) { pbuf_free(p); } }
public ER Connect(T_IPV4EP p_myaddr, T_IPV4EP p_dstaddr, TMO tmout) { err_t err; ip_addr ma = new ip_addr(0); ip_addr sa = new ip_addr(0); ma.addr = lwip.lwip_htonl(p_myaddr.ipaddr); err = m_lwIP.tcp.tcp_bind(m_Pcb, ma, lwip.lwip_htons(p_myaddr.portno)); if (err != err_t.ERR_OK) { return(ER.E_OBJ); } sa.addr = lwip.lwip_htonl(p_dstaddr.ipaddr); err = m_lwIP.tcp.tcp_connect(m_Pcb, sa, lwip.lwip_htons(p_dstaddr.portno), Connected); if (err != err_t.ERR_OK) { return(ER.E_OBJ); } Task task = m_Nucleus.GetTask(ID.TSK_SELF); if ((tmout != 0) && (task == null)) { return(ER.E_CTX); } if (task == null) { return(ER.E_TMOUT); } if (tmout == 0) { return(ER.E_TMOUT); } SetState(true, new TMO(tcp.TCP_TMR_INTERVAL), task, Intarval); ER ret = task.Wait(m_SendTaskQueue, TSKWAIT.TTW_TCP, m_CepID, tmout); switch (ret) { case ER.E_OK: if ((m_TPcb == null) || (m_TPcb.state != tcp_state.ESTABLISHED)) { return(ER.E_RLWAI); } break; case ER.E_TMOUT: return(ER.E_TMOUT); default: return(ER.E_RLWAI); } return(ER.E_OK); }
public static void ip_addr_debug_print(uint debug, ip_addr ipaddr) { uITron3.lwip.LWIP_DEBUGF(debug, "{0}.{1}.{2}.{3}", ipaddr != null ? ip_addr.ip4_addr1_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr2_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr3_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr4_16(ipaddr) : 0); }
internal static string to_string(ip_addr ipaddr) { return(String.Format("{0}.{1}.{2}.{3}", ipaddr != null ? ip_addr.ip4_addr1_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr2_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr3_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr4_16(ipaddr) : 0)); }
/** * Simple interface to ip_output_if. It finds the outgoing network * interface and calls upon ip_output_if to do the actual work. * * @param p the packet to send (p.payload points to the data, e.g. next * protocol header; if dest == ip.IP_HDRINCL, p already includes an IP * header and p.payload points to that IP header) * @param src the source IP address to send from (if src == IP_ADDR_ANY, the * IP address of the netif used to send is used as source address) * @param dest the destination IP address to send the packet to * @param ttl the TTL value to be set in the IP header * @param tos the TOS value to be set in the IP header * @param proto the PROTOCOL to be set in the IP header * * @return err_t.ERR_RTE if no route is found * see ip_output_if() for more return values */ public err_t ip_output(pbuf p, ip_addr src, ip_addr dest, byte ttl, byte tos, byte proto) { /* pbufs passed to IP must have a @ref-count of 1 as their payload pointer * gets altered as the packet is passed down the stack */ lwip.LWIP_ASSERT("p.ref == 1", p.@ref == 1); return(ip_output_if(p, src, dest, ttl, tos, proto)); }
/* lwip.inet_chksum_pseudo: * * Calculates the pseudo Internet checksum used by TCP and UDP for a pbuf chain. * IP addresses are expected to be in network byte order. * * @param p chain of pbufs over that a checksum should be calculated (ip data part) * @param src source ip address (used for checksum of pseudo header) * @param dst destination ip address (used for checksum of pseudo header) * @param proto ip protocol (used for checksum of pseudo header) * @param proto_len length of the ip data part (used for checksum of pseudo header) * @return checksum (as ushort) to be saved directly in the protocol header */ public static ushort inet_chksum_pseudo_partial(pbuf p, ip_addr src, ip_addr dest, byte proto, ushort proto_len, ushort chksum_len) { uint acc; uint addr; pbuf q; byte swapped; ushort chklen; acc = 0; swapped = 0; /* iterate through all pbuf in chain */ for (q = p; (q != null) && (chksum_len > 0); q = q.next) { lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): checksumming pbuf {0} (has next {1}) \n", q, q.next); chklen = q.len; if (chklen > chksum_len) { chklen = chksum_len; } acc += LWIP_CHKSUM(q.payload, chklen); chksum_len -= chklen; lwip.LWIP_ASSERT("delete me", chksum_len < 0x7fff); /*lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): unwrapped lwip_chksum()={0} \n", acc);*/ /* fold the upper bit down */ acc = FOLD_U32T(acc); if (q.len % 2 != 0) { swapped = (byte)(1 - swapped); acc = SWAP_BYTES_IN_WORD((ushort)acc); } /*lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): wrapped lwip_chksum()={0} \n", acc);*/ } if (swapped != 0) { acc = SWAP_BYTES_IN_WORD((ushort)acc); } addr = ip_addr.ip4_addr_get_u32(src); acc += (addr & 0xffffU); acc += ((addr >> 16) & 0xffffU); addr = ip_addr.ip4_addr_get_u32(dest); acc += (addr & 0xffffU); acc += ((addr >> 16) & 0xffffU); acc += (uint)lwip.lwip_htons((ushort)proto); acc += (uint)lwip.lwip_htons(proto_len); /* Fold 32-bit sum to 16 bits * calling this twice is propably faster than if statements... */ acc = FOLD_U32T(acc); acc = FOLD_U32T(acc); lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): pbuf chain lwip_chksum()={0}\n", acc); return((ushort)~(acc & 0xffffUL)); }
/** * Ascii internet address interpretation routine. * The value returned is in network order. * * @param cp IP address in ascii represenation (e.g. "127.0.0.1") * @return ip address in network order */ public static uint ipaddr_addr(string cp) { ip_addr val = new ip_addr(0); if (ipaddr_aton(cp, val) != 0) { return(ip_addr.ip4_addr_get_u32(val)); } return(IPADDR_NONE); }
private void ip_output(lwip netif, byte[] packet, ip_addr src, ip_addr dest, byte proto) { if (m_IPPacketBridge == null) { return; } byte[] data = Itron.GetIp4Packet(new pointer(packet, 0), packet.Length, src, dest, proto); m_IPPacketBridge.OutputData(data); }
public UdpCep(ID udpid, ref T_UDP_CCEP pk_cudp, Nucleus pNucleus, lwip lwip) { m_CepID = udpid; m_cudp = pk_cudp; m_Nucleus = pNucleus; m_lwIP = lwip; ip_addr addr = new ip_addr(pk_cudp.myaddr.ipaddr); m_Pcb = m_lwIP.udp.udp_new(); m_lwIP.udp.udp_bind(m_Pcb, addr, pk_cudp.myaddr.portno); udp.udp_recv(m_Pcb, recv, this); }
/* lwip.inet_chksum_pseudo: * * Calculates the pseudo Internet checksum used by TCP and UDP for a pbuf chain. * IP addresses are expected to be in network byte order. * * @param p chain of pbufs over that a checksum should be calculated (ip data part) * @param src source ip address (used for checksum of pseudo header) * @param dst destination ip address (used for checksum of pseudo header) * @param proto ip protocol (used for checksum of pseudo header) * @param proto_len length of the ip data part (used for checksum of pseudo header) * @return checksum (as ushort) to be saved directly in the protocol header */ public static ushort inet_chksum_pseudo(pbuf p, ip_addr src, ip_addr dest, byte proto, ushort proto_len) { uint acc; uint addr; pbuf q; byte swapped; acc = 0; swapped = 0; /* iterate through all pbuf in chain */ for (q = p; q != null; q = q.next) { lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): checksumming pbuf {0} (has next {1}) \n", q, q.next); acc += LWIP_CHKSUM(q.payload, q.len); /*lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): unwrapped lwip_chksum()={0} \n", acc);*/ /* just executing this next line is probably faster that the if statement needed * to check whether we really need to execute it, and does no harm */ acc = FOLD_U32T(acc); if (q.len % 2 != 0) { swapped = (byte)(1 - swapped); acc = SWAP_BYTES_IN_WORD((ushort)acc); } /*lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): wrapped lwip_chksum()={0} \n", acc);*/ } if (swapped != 0) { acc = SWAP_BYTES_IN_WORD((ushort)acc); } addr = ip_addr.ip4_addr_get_u32(src); acc += (addr & 0xffffU); acc += ((addr >> 16) & 0xffffU); addr = ip_addr.ip4_addr_get_u32(dest); acc += (addr & 0xffffU); acc += ((addr >> 16) & 0xffffU); acc += (uint)lwip.lwip_htons((ushort)proto); acc += (uint)lwip.lwip_htons(proto_len); /* Fold 32-bit sum to 16 bits * calling this twice is propably faster than if statements... */ acc = FOLD_U32T(acc); acc = FOLD_U32T(acc); lwip.LWIP_DEBUGF(opt.INET_DEBUG, "inet_chksum_pseudo(): pbuf chain lwip_chksum()={0}\n", acc); return((ushort)~(acc & 0xffffU)); }
/** * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used. * * @param addr ip address in network order to convert * @param buf target buffer where the pointer is stored * @param buflen length of buf * @return either pointer to buf which now holds the ASCII * representation of addr or null if buf was too small */ public static string ipaddr_ntoa_r(ip_addr addr, char[] buf) { byte[] s_addr; char[] inv = new char[3]; int rp; int ap; byte rem; byte n; byte i; int len = 0; s_addr = BitConverter.GetBytes(ip_addr.ip4_addr_get_u32(addr)); rp = 0; ap = 0; for (n = 0; n < 4; n++) { i = 0; do { rem = (byte)(s_addr[ap] % 10); s_addr[ap] /= (byte)10; inv[i++] = (char)('0' + rem); } while (s_addr[ap] != 0); while ((i--) != 0) { if (len++ >= buf.Length) { return(null); } buf[rp++] = inv[i]; } if (len++ >= buf.Length) { return(null); } buf[rp++] = '.'; ap++; } buf[--rp] = '\0'; return(buf.ToString()); }
/** * Determine if an address is a broadcast address on a network interface * * @param addr address to be checked * @param netif the network interface against which the address is checked * @return returns non-zero if the address is a broadcast address */ public static bool ip4_addr_isbroadcast(uint addr, lwip netif) { ip_addr ipaddr = new ip_addr(0); ip_addr.ip4_addr_set_u32(ipaddr, addr); /* all ones (broadcast) or all zeroes (old skool broadcast) */ if ((~addr == IPADDR_ANY) || (addr == IPADDR_ANY)) { return(true); /* no broadcast support on this network interface? */ } else if ((netif.flags & lwip.NETIF_FLAG_BROADCAST) == 0) { /* the given address cannot be a broadcast address * nor can we check against any broadcast addresses */ return(false); /* address matches network interface address exactly? => no broadcast */ } else if (addr == ip_addr.ip4_addr_get_u32(netif.ip_addr)) { return(false); /* on the same (sub) network... */ } else if (ip_addr.ip_addr_netcmp(ipaddr, netif.ip_addr, netif.netmask) /* ...and host identifier bits are all ones? =>... */ && ((addr & ~ip_addr.ip4_addr_get_u32(netif.netmask)) == (IPADDR_BROADCAST & ~ip_addr.ip4_addr_get_u32(netif.netmask)))) { /* => network broadcast address */ return(true); } else { return(false); } }
private void recv(object arg, udp_pcb pcb, pbuf p, ip_addr addr, ushort port) { System.Diagnostics.Debug.Assert((arg == this) && (pcb == m_Pcb)); pointer data = new pointer(new byte[sizeof(ushort) + T_IPV4EP.length + p.tot_len], 0); T_IPV4EP p_dstaddr = new T_IPV4EP(data, sizeof(ushort)); pointer p_dat = new pointer(data, sizeof(ushort) + T_IPV4EP.length); data.SetValue(p.tot_len); p_dstaddr.ipaddr = lwip.lwip_ntohl(addr.addr); p_dstaddr.portno = lwip.lwip_ntohs(port); for (pbuf q = p; q != null; q = q.next) { pointer.memcpy(p_dat, q.payload, q.len); p_dat += q.len; } lock (m_CallBack) { m_CallBack.Enqueue(data); } SetState(true, TMO.TMO_POL, null, OnTimeOut); }
public ER SendData(T_IPV4EP p_dstaddr, pointer p_dat, int len, TMO tmout) { pbuf buf; ip_addr addr = new ip_addr(lwip.lwip_htonl(p_dstaddr.ipaddr)); buf = m_lwIP.pbuf_alloc(pbuf_layer.PBUF_TRANSPORT, (ushort)len, pbuf_type.PBUF_POOL); if (buf == null) { return(ER.E_NOMEM); } int pos = 0; for (pbuf q = buf; q != null; q = q.next) { pointer.memcpy(q.payload, new pointer(p_dat, pos), q.len); pos += q.len; } m_lwIP.udp.udp_sendto(m_Pcb, buf, addr, p_dstaddr.portno); return(ER.E_OK); }
public static bool ip_addr_ismulticast(ip_addr addr1) { return (((addr1).addr & lwip.PP_HTONL(0xf0000000U)) == lwip.PP_HTONL(0xe0000000U)); }
public static bool ip_addr_isbroadcast(ip_addr ipaddr, lwip netif) { return ip_addr.ip4_addr_isbroadcast(ipaddr.addr, netif); }
/** Get the network address by combining host address with netmask */ public static void ip_addr_get_network(ip_addr target, ip_addr host, ip_addr netmask) { target.addr = host.addr & netmask.addr; }
/** Copy IP address - faster than ip_addr.ip_addr_set: no null check */ public static void ip_addr_copy(ip_addr dest, ip_addr src) { dest.addr = src.addr; }
/** * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used. * * @param addr ip address in network order to convert * @param buf target buffer where the pointer is stored * @param buflen length of buf * @return either pointer to buf which now holds the ASCII * representation of addr or null if buf was too small */ public static string ipaddr_ntoa_r(ip_addr addr, char[] buf) { byte[] s_addr; char[] inv = new char[3]; int rp; int ap; byte rem; byte n; byte i; int len = 0; s_addr = BitConverter.GetBytes(ip_addr.ip4_addr_get_u32(addr)); rp = 0; ap = 0; for (n = 0; n < 4; n++) { i = 0; do { rem = (byte)(s_addr[ap] % 10); s_addr[ap] /= (byte)10; inv[i++] = (char)('0' + rem); } while (s_addr[ap] != 0); while ((i--) != 0) { if (len++ >= buf.Length) { return null; } buf[rp++] = inv[i]; } if (len++ >= buf.Length) { return null; } buf[rp++] = '.'; ap++; } buf[--rp] = '\0'; return buf.ToString(); }
public static ushort ip4_addr4_16(ip_addr ipaddr) { return((ushort)ip_addr.ip4_addr4(ipaddr)); }
/** Set address to loopback address */ public static void ip_addr_set_loopback(ip_addr ipaddr) { ipaddr.addr = lwip.PP_HTONL(IPADDR_LOOPBACK); }
public static bool ip_addr_netmask_valid(ip_addr netmask) { return(ip_addr.ip4_addr_netmask_valid((netmask).addr)); }
public static bool ip_addr_ismulticast(ip_addr addr1) { return(((addr1).addr & lwip.PP_HTONL(0xf0000000U)) == lwip.PP_HTONL(0xe0000000U)); }
static ip_addr() { IP_ADDR_ANY = ip_addr_any; IP_ADDR_BROADCAST = ip_addr_broadcast; }
public static bool ip_addr_islinklocal(ip_addr addr1) { return(((addr1).addr & lwip.PP_HTONL(0xffff0000U)) == lwip.PP_HTONL(0xa9fe0000U)); }
public static byte ip4_addr4(ip_addr ipaddr) { return(BitConverter.GetBytes(ipaddr.addr)[3]); }
/** * Convert numeric IP address into decimal dotted ASCII representation. * returns ptr to static buffer; not reentrant! * * @param addr ip address in network order to convert * @return pointer to a global static (!) buffer that holds the ASCII * represenation of addr */ public static string ipaddr_ntoa(ip_addr addr) { char[] str = new char[16]; return(ipaddr_ntoa_r(addr, str)); }
/** * Check whether "cp" is a valid ascii representation * of an Internet address and convert to a binary address. * Returns 1 if the address is valid, 0 if not. * This replaces inet_addr, the return value from which * cannot distinguish between failure and a local broadcast address. * * @param cp IP address in ascii represenation (e.g. "127.0.0.1") * @param addr pointer to which to save the ip address in network order * @return 1 if cp could be converted to addr, 0 on failure */ public static int ipaddr_aton(string cp, ip_addr addr) { uint val; byte @base; char c; uint[] parts = new uint[4]; int pp = 0; int p = 0; cp += "\0"; c = cp[0]; for (;;) { /* * Collect number up to ``.''. * Values are specified as for C: * 0x=hex, 0=octal, 1-9=decimal. */ if (!isdigit(c)) { return(0); } val = 0; @base = 10; if (c == '0') { c = cp[++p]; if (c == 'x' || c == 'X') { @base = 16; c = cp[++p]; } else { @base = 8; } } for (;;) { if (isdigit(c)) { val = (val * @base) + (uint)(c - (byte)'0'); c = cp[++p]; } else if (@base == 16 && isxdigit(c)) { val = (val << 4) | (uint)(c + 10 - (islower(c) ? (byte)'a' : (byte)'A')); c = cp[++p]; } else { break; } } if (c == '.') { /* * Internet format: * a.b.c.d * a.b.c (with c treated as 16 bits) * a.b (with b treated as 24 bits) */ if (pp >= 3) { return(0); } parts[pp++] = val; c = cp[++p]; } else { break; } } /* * Check for trailing characters. */ if (c != '\0' && !isspace(c)) { return(0); } /* * Concoct the address according to * the number of parts specified. */ switch (pp + 1) { case 0: return(0); /* initial nondigit */ case 1: /* a -- 32 bits */ break; case 2: /* a.b -- 8.24 bits */ if (val > 0xffffffUL) { return(0); } val |= parts[0] << 24; break; case 3: /* a.b.c -- 8.8.16 bits */ if (val > 0xffff) { return(0); } val |= (parts[0] << 24) | (parts[1] << 16); break; case 4: /* a.b.c.d -- 8.8.8.8 bits */ if (val > 0xff) { return(0); } val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8); break; default: lwip.LWIP_ASSERT("unhandled", false); break; } if (addr != null) { ip_addr.ip4_addr_set_u32(addr, lwip.lwip_htonl(val)); } return(1); }
public static bool ip_addr_netmask_valid(ip_addr netmask) { return ip_addr.ip4_addr_netmask_valid((netmask).addr); }
/** Set address to IPADDR_ANY (no need for lwip.lwip_htonl()) */ public static void ip_addr_set_any(ip_addr ipaddr) { ipaddr.addr = IPADDR_ANY; }
/** Like ip.ip_output, but takes and addr_hint pointer that is passed on to netif.addr_hint * before calling ip_output_if. * * @param p the packet to send (p.payload points to the data, e.g. next protocol header; if dest == ip.IP_HDRINCL, p already includes an IP header and p.payload points to that IP header) * @param src the source IP address to send from (if src == IP_ADDR_ANY, the * IP address of the netif used to send is used as source address) * @param dest the destination IP address to send the packet to * @param ttl the TTL value to be set in the IP header * @param tos the TOS value to be set in the IP header * @param proto the PROTOCOL to be set in the IP header * @param addr_hint address hint pointer set to netif.addr_hint before * calling ip_output_if() * * @return err_t.ERR_RTE if no route is found * see ip_output_if() for more return values */ public err_t ip_output_hinted(pbuf p, ip_addr src, ip_addr dest, byte ttl, byte tos, byte proto, object addr_hint) { err_t err; /* pbufs passed to IP must have a @ref-count of 1 as their payload pointer gets altered as the packet is passed down the stack */ lwip.LWIP_ASSERT("p.ref == 1", p.@ref == 1); err = ip_output_if(p, src, dest, ttl, tos, proto); return err; }
/** For backwards compatibility */ public static string ip_ntoa(ip_addr ipaddr) { return ipaddr_ntoa(ipaddr); }
public static bool ip_addr_isbroadcast(ip_addr ipaddr, lwip netif) { return(ip_addr.ip4_addr_isbroadcast(ipaddr.addr, netif)); }
/** * Convert numeric IP address into decimal dotted ASCII representation. * returns ptr to static buffer; not reentrant! * * @param addr ip address in network order to convert * @return pointer to a global static (!) buffer that holds the ASCII * represenation of addr */ public static string ipaddr_ntoa(ip_addr addr) { char[] str = new char[16]; return ipaddr_ntoa_r(addr, str); }
public static bool ip_addr_cmp(ip_addr addr1, ip_addr addr2) { return ((addr1).addr == (addr2).addr); }
/** Set an IP address given by the four byte-parts. Little-endian version that prevents the use of lwip.lwip_htonl. */ public static void IP4_ADDR(ip_addr ipaddr, byte a, byte b, byte c, byte d) { ipaddr.addr = ((uint)((d) & 0xff) << 24) | ((uint)((c) & 0xff) << 16) | ((uint)((b) & 0xff) << 8) | (uint)((a) & 0xff); }
public static byte ip4_addr4(ip_addr ipaddr) { return BitConverter.GetBytes(ipaddr.addr)[3]; }
public static bool ip_addr_isany(ip_addr addr1) { return ((addr1) == null || (addr1).addr == IPADDR_ANY); }
public static bool ip_addr_isany(ip_addr addr1) { return((addr1) == null || (addr1).addr == IPADDR_ANY); }
public static bool ip_addr_islinklocal(ip_addr addr1) { return (((addr1).addr & lwip.PP_HTONL(0xffff0000U)) == lwip.PP_HTONL(0xa9fe0000U)); }
public static bool ip_addr_cmp(ip_addr addr1, ip_addr addr2) { return((addr1).addr == (addr2).addr); }
/** * Determine if two address are on the same network. * * @arg addr1 IP address 1 * @arg addr2 IP address 2 * @arg mask network identifier mask * @return !0 if the network identifiers of both address match */ public static bool ip_addr_netcmp(ip_addr addr1, ip_addr addr2, ip_addr mask) { return (((addr1).addr & (mask).addr) == ((addr2).addr & (mask).addr)); }
/** IPv4 only: set the IP address given as an uint */ public static void ip4_addr_set_u32(ip_addr dest_ipaddr, uint src_u32) { dest_ipaddr.addr = src_u32; }
/** Safely copy one IP address to another (src may be null) */ public static void ip_addr_set(ip_addr dest, ip_addr src) { dest.addr = (src == null ? 0 : src.addr); }
/** MEMCPY-like copying of IP addresses where addresses are known to be * 16-bit-aligned if the port is correctly configured (so a port could define * this to copying 2 ushort's) - no null-pointer-checking needed. */ public static void IPADDR2_COPY(ip_addr dest, ip_addr src) { dest.addr = src.addr; }
/** Safely copy one IP address to another and change byte order * from host- to network-order. */ public static void ip_addr_set_hton(ip_addr dest, ip_addr src) { dest.addr = (src == null ? 0U : lwip.lwip_htonl(src.addr)); }
/** * Ascii internet address interpretation routine. * The value returned is in network order. * * @param cp IP address in ascii represenation (e.g. "127.0.0.1") * @return ip address in network order */ public static uint ipaddr_addr(string cp) { ip_addr val = new ip_addr(0); if (ipaddr_aton(cp, val) != 0) { return ip_addr.ip4_addr_get_u32(val); } return (IPADDR_NONE); }
/** Set complete address to zero */ public static void ip_addr_set_zero(ip_addr ipaddr) { ipaddr.addr = 0; }
/** * Check whether "cp" is a valid ascii representation * of an Internet address and convert to a binary address. * Returns 1 if the address is valid, 0 if not. * This replaces inet_addr, the return value from which * cannot distinguish between failure and a local broadcast address. * * @param cp IP address in ascii represenation (e.g. "127.0.0.1") * @param addr pointer to which to save the ip address in network order * @return 1 if cp could be converted to addr, 0 on failure */ public static int ipaddr_aton(string cp, ip_addr addr) { uint val; byte @base; char c; uint[] parts = new uint[4]; int pp = 0; int p = 0; cp += "\0"; c = cp[0]; for (;;) { /* * Collect number up to ``.''. * Values are specified as for C: * 0x=hex, 0=octal, 1-9=decimal. */ if (!isdigit(c)) return (0); val = 0; @base = 10; if (c == '0') { c = cp[++p]; if (c == 'x' || c == 'X') { @base = 16; c = cp[++p]; } else @base = 8; } for (;;) { if (isdigit(c)) { val = (val * @base) + (uint)(c - (byte)'0'); c = cp[++p]; } else if (@base == 16 && isxdigit(c)) { val = (val << 4) | (uint)(c + 10 - (islower(c) ? (byte)'a' : (byte)'A')); c = cp[++p]; } else break; } if (c == '.') { /* * Internet format: * a.b.c.d * a.b.c (with c treated as 16 bits) * a.b (with b treated as 24 bits) */ if (pp >= 3) { return (0); } parts[pp++] = val; c = cp[++p]; } else break; } /* * Check for trailing characters. */ if (c != '\0' && !isspace(c)) { return (0); } /* * Concoct the address according to * the number of parts specified. */ switch (pp + 1) { case 0: return (0); /* initial nondigit */ case 1: /* a -- 32 bits */ break; case 2: /* a.b -- 8.24 bits */ if (val > 0xffffffUL) { return (0); } val |= parts[0] << 24; break; case 3: /* a.b.c -- 8.8.16 bits */ if (val > 0xffff) { return (0); } val |= (parts[0] << 24) | (parts[1] << 16); break; case 4: /* a.b.c.d -- 8.8.8.8 bits */ if (val > 0xff) { return (0); } val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8); break; default: lwip.LWIP_ASSERT("unhandled", false); break; } if (addr != null) { ip_addr.ip4_addr_set_u32(addr, lwip.lwip_htonl(val)); } return (1); }
internal static string to_string(ip_addr ipaddr) { return String.Format("{0}.{1}.{2}.{3}", ipaddr != null ? ip_addr.ip4_addr1_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr2_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr3_16(ipaddr) : 0, ipaddr != null ? ip_addr.ip4_addr4_16(ipaddr) : 0); }
/** For backwards compatibility */ public static string ip_ntoa(ip_addr ipaddr) { return(ipaddr_ntoa(ipaddr)); }
internal err_t ip_input(pbuf p, ip_addr src, ip_addr dest, byte proto) { ++lwip_stats.ip.recv; /* copy IP addresses to aligned ip_addr */ ip_addr.ip_addr_copy(current_iphdr_dest, dest); ip_addr.ip_addr_copy(current_iphdr_src, src); /* broadcast or multicast packet source address? Compliant with RFC 1122: 3.2.1.3 */ #if IP_ACCEPT_LINK_LAYER_ADDRESSING /* DHCP servers need 0.0.0.0 to be allowed as source address (RFC 1.1.2.2: 3.2.1.3/a) */ if (check_ip_src != 0 && !ip_addr.ip_addr_isany(ip.current_iphdr_src)) #endif // IP_ACCEPT_LINK_LAYER_ADDRESSING { if ((ip_addr.ip_addr_isbroadcast(current_iphdr_src, this)) || (ip_addr.ip_addr_ismulticast(current_iphdr_src))) { /* packet source is not valid */ lwip.LWIP_DEBUGF(opt.IP_DEBUG | lwip.LWIP_DBG_TRACE | lwip.LWIP_DBG_LEVEL_WARNING, "ip_input: packet source is not valid.\n"); /* free (drop) packet pbufs */ pbuf_free(p); ++lwip_stats.ip.drop; //snmp.snmp_inc_ipinaddrerrors(); //snmp.snmp_inc_ipindiscards(); return(err_t.ERR_OK); } } /* send to upper layers */ lwip.LWIP_DEBUGF(opt.IP_DEBUG, "ip_input: \n"); #if IP_DEBUG ip_debug_print(p); #endif lwip.LWIP_DEBUGF(opt.IP_DEBUG, "ip_input: p.len {0} p.tot_len {1}\n", p.len, p.tot_len); //lwip.current_header = iphdr; #if LWIP_RAW /* raw input did not eat the packet? */ if (raw.raw_input(p, inp) == 0) #endif // LWIP_RAW { switch (proto) { #if LWIP_UDP case lwip.IP_PROTO_UDP: #if LWIP_UDPLITE case lwip.IP_PROTO_UDPLITE: #endif // LWIP_UDPLITE //snmp.snmp_inc_ipindelivers(); udp.udp_input(p, this, proto == lwip.IP_PROTO_UDPLITE); break; #endif // LWIP_UDP #if LWIP_TCP case lwip.IP_PROTO_TCP: //snmp.snmp_inc_ipindelivers(); tcp.tcp_input(p, this); break; #endif // LWIP_TCP #if LWIP_ICMP case lwip.IP_PROTO_ICMP: //snmp.snmp_inc_ipindelivers(); lwip.icmp.icmp_input(p, inp); break; #endif // LWIP_ICMP #if LWIP_IGMP case lwip.IP_PROTO_IGMP: lwip.igmp.igmp_input(p, inp, lwip.current_iphdr_dest); break; #endif // LWIP_IGMP default: #if LWIP_ICMP /* send ICMP destination protocol unreachable unless is was a broadcast */ if (!ip_addr.ip_addr_isbroadcast(lwip.current_iphdr_dest, inp) && !ip_addr.ip_addr_ismulticast(lwip.current_iphdr_dest)) { p.payload = iphdr; lwip.icmp.icmp_dest_unreach(p, icmp_dur_type.ICMP_DUR_PROTO); } #endif // LWIP_ICMP pbuf_free(p); LWIP_DEBUGF(opt.IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, "Unsupported transport protocol {0}\n", proto); ++lwip_stats.ip.proterr; ++lwip_stats.ip.drop; //snmp.snmp_inc_ipinunknownprotos(); break; } } //lwip.current_header = null; ip_addr.ip_addr_set_any(current_iphdr_src); ip_addr.ip_addr_set_any(current_iphdr_dest); return(err_t.ERR_OK); }
/** IPv4 only: get the IP address as an uint */ public static uint ip4_addr_get_u32(ip_addr src_ipaddr) { return src_ipaddr.addr; }
public static ushort ip4_addr4_16(ip_addr ipaddr) { return ((ushort)ip_addr.ip4_addr4(ipaddr)); }
/** * Determine if an address is a broadcast address on a network interface * * @param addr address to be checked * @param netif the network interface against which the address is checked * @return returns non-zero if the address is a broadcast address */ public static bool ip4_addr_isbroadcast(uint addr, lwip netif) { ip_addr ipaddr = new ip_addr(0); ip_addr.ip4_addr_set_u32(ipaddr, addr); /* all ones (broadcast) or all zeroes (old skool broadcast) */ if ((~addr == IPADDR_ANY) || (addr == IPADDR_ANY)) { return true; /* no broadcast support on this network interface? */ } else if ((netif.flags & lwip.NETIF_FLAG_BROADCAST) == 0) { /* the given address cannot be a broadcast address * nor can we check against any broadcast addresses */ return false; /* address matches network interface address exactly? => no broadcast */ } else if (addr == ip_addr.ip4_addr_get_u32(netif.ip_addr)) { return false; /* on the same (sub) network... */ } else if (ip_addr.ip_addr_netcmp(ipaddr, netif.ip_addr, netif.netmask) /* ...and host identifier bits are all ones? =>... */ && ((addr & ~ip_addr.ip4_addr_get_u32(netif.netmask)) == (IPADDR_BROADCAST & ~ip_addr.ip4_addr_get_u32(netif.netmask)))) { /* => network broadcast address */ return true; } else { return false; } }