ChronosXYZ/netsukuku
1
0
Fork 0
mirror of https://github.com/ChronosX88/netsukuku.git synced 2024-11-23 02:32:18 +00:00
Code Issues Projects Releases Wiki Activity
e542a51345
netsukuku/src/inet.c

1136 lines
26 KiB
C
Raw Blame History

/* This file is part of Netsukuku
* (c) Copyright 2005 Andrea Lo Pumo aka AlpT <alpt@freaknet.org>
*
* This source code is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation; either version 2 of the License,
* or (at your option) any later version.
*
* This source code is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* Please refer to the GNU Public License for more details.
*
* You should have received a copy of the GNU Public License along with
* this source code; if not, write to:
* Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "includes.h"
#include "common.h"
#include "ipv6-gmp.h"
#include "libnetlink.h"
#include "ll_map.h"
#include "inet.h"
#include "endianness.h"
/*
* inet_ntohl: Converts each element of `data' from network to host order. If
* `family' is equal to AF_INET6, the array is swapped too (on big endian
* machine).
*/
void inet_ntohl(u_int *data, int family)
{
#if BYTE_ORDER == LITTLE_ENDIAN
if(family==AF_INET) {
data[0]=ntohl(data[0]);
} else {
int i;
swap_ints(MAX_IP_INT, data, data);
for(i=0; i<MAX_IP_INT; i++)
data[i]=ntohl(data[i]);
}
#endif
}
/*
* inet_htonl: Converts each element of `data' from host to network order. If
* `family' is equal to AF_INET6, the array is swapped too (on big endian
* machine).
*/
void inet_htonl(u_int *data, int family)
{
#if BYTE_ORDER == LITTLE_ENDIAN
if(family==AF_INET) {
data[0]=htonl(data[0]);
} else {
int i;
swap_ints(MAX_IP_INT, data, data);
for(i=0; i<MAX_IP_INT; i++)
data[i]=htonl(data[i]);
}
#endif
}
/*
* inet_setip_raw: fills the `ip' inet_prefix struct with `data' and `family'.
*/
int inet_setip_raw(inet_prefix *ip, u_int *data, int family)
{
ip->family=family;
setzero(ip->data, sizeof(ip->data));
if(family==AF_INET) {
ip->data[0]=data[0];
ip->len=4;
} else if(family==AF_INET6) {
memcpy(ip->data, data, sizeof(ip->data));
ip->len=16;
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
ip->bits=ip->len<<3; /* bits=len*8 */
return 0;
}
/*
* inet_setip: fills the `ip' inet_prefix struct with `data' and `family'.
* Note that it does a network to host order conversion on `data'.
*/
int inet_setip(inet_prefix *ip, u_int *data, int family)
{
inet_setip_raw(ip, data, family);
inet_ntohl(ip->data, ip->family);
return 0;
}
int inet_setip_bcast(inet_prefix *ip, int family)
{
if(family==AF_INET) {
u_int data[MAX_IP_INT]={0, 0, 0, 0};
data[0]=INADDR_BROADCAST;
inet_setip(ip, data, family);
} else if(family==AF_INET6) {
u_int data[MAX_IP_INT]=IPV6_ADDR_BROADCAST;
inet_setip(ip, data, family);
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
return 0;
}
int inet_setip_anyaddr(inet_prefix *ip, int family)
{
if(family==AF_INET) {
u_int data[MAX_IP_INT]={0, 0, 0, 0};
data[0]=INADDR_ANY;
inet_setip(ip, data, family);
} else if(family==AF_INET6) {
struct in6_addr ipv6=IN6ADDR_ANY_INIT;
inet_setip(ip, (u_int *)(&ipv6), family);
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
return 0;
}
int inet_setip_loopback(inet_prefix *ip, int family)
{
if(family==AF_INET) {
u_int data[MAX_IP_INT]={0, 0, 0, 0};
data[0]=LOOPBACK_IP;
inet_setip(ip, data, family);
inet_htonl(ip->data, ip->family);
} else if(family==AF_INET6) {
u_int data[MAX_IP_INT]=LOOPBACK_IPV6;
inet_setip(ip, data, family);
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
return 0;
}
/*
* inet_setip_localaddr: Restrict the `ip' to a local private class changing the
* first byte of the `ip'. `class' specifies what restricted class is currently
* being used (10.x.x.x or 172.16.x.x). In ipv6 the site local class is the
* default.
*/
int inet_setip_localaddr(inet_prefix *ip, int family, int class)
{
if(family==AF_INET) {
if(class == RESTRICTED_10)
ip->data[0] = NTK_RESTRICTED_10_MASK(ip->data[0]);
else
ip->data[0] = NTK_RESTRICTED_172_MASK(ip->data[0]);
} else if(family==AF_INET6) {
ip->data[0] = NTK_RESTRICTED_IPV6_MASK(ip->data[0]);
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
return 0;
}
/*
* inet_is_ip_local: verifies if `ip' is a local address. If it is, 1 is
* returned. `class' specifies what restricted class is currently
* being used (10.x.x.x or 172.16.x.x). In ipv6 the site local class is the
* default.
*/
int inet_is_ip_local(inet_prefix *ip, int class)
{
if(ip->family==AF_INET) {
if(class == RESTRICTED_10)
return ip->data[0] == NTK_RESTRICTED_10_MASK(ip->data[0]);
else
return ip->data[0] == NTK_RESTRICTED_172_MASK(ip->data[0]);
} else if(ip->family==AF_INET6)
return ip->data[0] == NTK_RESTRICTED_IPV6_MASK(ip->data[0]);
else
fatal(ERROR_MSG "family not supported", ERROR_POS);
return 0;
}
void inet_copy(inet_prefix *dst, inet_prefix *src)
{
memcpy(dst, src, sizeof(inet_prefix));
}
/*
* inet_copy_ipdata_raw: copies `ip'->data in `dst_data'.
*/
void inet_copy_ipdata_raw(u_int *dst_data, inet_prefix *ip)
{
memcpy(dst_data, ip->data, MAX_IP_SZ);
}
/*
* inet_copy_ipdata: copies `ip'->data in `dst_data' and converts it in network
* order.
*/
void inet_copy_ipdata(u_int *dst_data, inet_prefix *ip)
{
inet_prefix tmp_ip;
inet_copy(&tmp_ip, ip);
inet_htonl(tmp_ip.data, tmp_ip.family);
memcpy(dst_data, tmp_ip.data, MAX_IP_SZ);
}
/*
* pack_inet_prefix: packs the `ip' inet_prefix struct and stores it in
* `pack', which must be INET_PREFIX_PACK_SZ bytes big. `pack' will be in
* network order.
*/
void pack_inet_prefix(inet_prefix *ip, char *pack)
{
char *buf;
buf=pack;
memcpy(buf, &ip->family, sizeof(u_char));
buf+=sizeof(u_char);
memcpy(buf, &ip->len, sizeof(u_short));
buf+=sizeof(u_short);
memcpy(buf, &ip->bits, sizeof(u_char));
buf+=sizeof(u_char);
memcpy(buf, ip->data, MAX_IP_SZ);
inet_htonl((u_int *)buf, ip->family);
buf+=MAX_IP_SZ;
ints_host_to_network(pack, inet_prefix_iinfo);
}
/*
* unpack_inet_prefix: restores in `ip' the inet_prefix struct contained in `pack'.
* Note that `pack' will be modified during the restoration.
*/
void unpack_inet_prefix(inet_prefix *ip, char *pack)
{
char *buf;
buf=pack;
ints_network_to_host(pack, inet_prefix_iinfo);
memcpy(&ip->family, buf, sizeof(u_char));
buf+=sizeof(u_char);
memcpy(&ip->len, buf, sizeof(u_short));
buf+=sizeof(u_short);
memcpy(&ip->bits, buf, sizeof(u_char));
buf+=sizeof(u_char);
memcpy(ip->data, buf, MAX_IP_SZ);
inet_ntohl(ip->data, ip->family);
buf+=MAX_IP_SZ;
}
/*
* inet_addr_match: without hesitating this function was robbed from iproute2.
* It compares a->data wih b->data matching `bits'# bits.
*/
int inet_addr_match(const inet_prefix *a, const inet_prefix *b, int bits)
{
const uint32_t *a1 = a->data;
const uint32_t *a2 = b->data;
int words = bits >> 0x05;
bits &= 0x1f;
if (words)
if (memcmp(a1, a2, words << 2))
return -1;
if (bits) {
uint32_t w1, w2;
uint32_t mask;
w1 = a1[words];
w2 = a2[words];
mask = htonl((0xffffffff) << (0x20 - bits));
if ((w1 ^ w2) & mask)
return 1;
}
return 0;
}
int ipv6_addr_type(inet_prefix addr)
{
int type;
u_int st;
st = htonl(addr.data[0]);
if ((st & htonl(0xFF000000)) == htonl(0xFF000000)) {
type = IPV6_ADDR_MULTICAST;
switch((st & htonl(0x00FF0000))) {
case __constant_htonl(0x00010000):
type |= IPV6_ADDR_LOOPBACK;
break;
case __constant_htonl(0x00020000):
type |= IPV6_ADDR_LINKLOCAL;
break;
case __constant_htonl(0x00050000):
type |= IPV6_ADDR_SITELOCAL;
break;
};
return type;
}
type = IPV6_ADDR_UNICAST;
/* Consider all addresses with the first three bits different of
000 and 111 as finished.
*/
if ((st & htonl(0xE0000000)) != htonl(0x00000000) &&
(st & htonl(0xE0000000)) != htonl(0xE0000000))
return type;
if ((st & htonl(0xFFC00000)) == htonl(0xFE800000))
return (IPV6_ADDR_LINKLOCAL | type);
if ((st & htonl(0xFFC00000)) == htonl(0xFEC00000))
return (IPV6_ADDR_SITELOCAL | type);
if ((addr.data[0] | addr.data[1]) == 0) {
if (addr.data[2] == 0) {
if (addr.data[3] == 0)
return IPV6_ADDR_ANY;
if (htonl(addr.data[3]) == htonl(0x00000001))
return (IPV6_ADDR_LOOPBACK | type);
return (IPV6_ADDR_COMPATv4 | type);
}
if (htonl(addr.data[2]) == htonl(0x0000ffff))
return IPV6_ADDR_MAPPED;
}
st &= htonl(0xFF000000);
if (st == 0)
return IPV6_ADDR_RESERVED;
st &= htonl(0xFE000000);
if (st == htonl(0x02000000))
return IPV6_ADDR_RESERVED; /* for NSAP */
if (st == htonl(0x04000000))
return IPV6_ADDR_RESERVED; /* for IPX */
return type;
}
/*
* inet_validate_ip: returns 0 is `ip' a valid IP which can be set by
* Netsukuku to a network interface
*/
int inet_validate_ip(inet_prefix ip)
{
int type, ipv4;
if(ip.family==AF_INET) {
ipv4=htonl(ip.data[0]);
if(MULTICAST(ipv4) || BADCLASS(ipv4) || ZERONET(ipv4)
|| LOOPBACK(ipv4) || NTK_PRIVATE_C(ipv4) ||
(!restricted_mode && NTK_PRIVATE_B(ipv4)))
return -EINVAL;
} else if(ip.family==AF_INET6) {
type=ipv6_addr_type(ip);
if( (type & IPV6_ADDR_MULTICAST) || (type & IPV6_ADDR_RESERVED) ||
(type & IPV6_ADDR_LOOPBACK))
return -EINVAL;
}
if(is_bufzero((char *)ip.data, MAX_IP_SZ))
return -EINVAL;
return 0;
}
/*\
*
* * * Conversion functions... * *
*
\*/
/*
* ipraw_to_str: It returns the string which represents the given ip in host
* order.
*/
const char *ipraw_to_str(u_int ip[MAX_IP_INT], int family)
{
struct in_addr src;
struct in6_addr src6;
static char dst[INET_ADDRSTRLEN], dst6[INET6_ADDRSTRLEN];
if(family==AF_INET) {
src.s_addr=htonl(ip[0]);
inet_ntop(family, &src, dst, INET_ADDRSTRLEN);
return dst;
} else if(family==AF_INET6) {
inet_htonl(ip, family);
memcpy(&src6, ip, MAX_IP_SZ);
inet_ntop(family, &src6, dst6, INET6_ADDRSTRLEN);
return dst6;
}
return 0;
}
/*
* inet_to_str: returns the string rapresentation of `ip'
*/
const char *inet_to_str(inet_prefix ip)
{
return ipraw_to_str(ip.data, ip.family);
}
/*
* str_to_inet: it converts the IP address string contained in `src' and
* terminated by a `\0' char to an inet_prefix struct. The result is stored in
* `ip'. On error -1 is returned.
*/
int str_to_inet(const char *src, inet_prefix *ip)
{
struct in_addr dst;
struct in6_addr dst6;
int family,res;
u_int *data;
setzero(ip, sizeof(inet_prefix));
if(strstr(src, ":")) {
family=AF_INET6;
data=(u_int *)&dst6;
} else {
family=AF_INET;
data=(u_int *)&dst;
}
if((res=inet_pton(family, src, (void *)data)) < 0) {
debug(DBG_NORMAL, ERROR_MSG "error -> %s.",
ERROR_FUNC, strerror(errno));
return -1;
}
if (!res) {
debug(DBG_NORMAL, ERROR_MSG "impossible to convert \"%s\":"
" invalid address.", ERROR_FUNC, src);
return -1;
}
inet_setip(ip, data, family);
return 0;
}
/*
* inet_to_sockaddr: Converts a inet_prefix struct to a sockaddr struct
*/
int inet_to_sockaddr(inet_prefix *ip, u_short port, struct sockaddr *dst,
socklen_t *dstlen)
{
port=htons(port);
if(ip->family==AF_INET) {
struct sockaddr_in sin;
setzero(&sin, sizeof(struct sockaddr_in));
sin.sin_family = ip->family;
sin.sin_port = port;
sin.sin_addr.s_addr = htonl(ip->data[0]);
memcpy(dst, &sin, sizeof(struct sockaddr_in));
if(dstlen)
*dstlen=sizeof(struct sockaddr_in);
} else if(ip->family==AF_INET6) {
struct sockaddr_in6 sin6;
setzero(&sin6, sizeof(struct sockaddr_in6));
sin6.sin6_family = ip->family;
sin6.sin6_port = port;
sin6.sin6_flowinfo = 0;
memcpy(&sin6.sin6_addr, ip->data, MAX_IP_SZ);
inet_htonl((u_int *)&sin6.sin6_addr, ip->family);
memcpy(dst, &sin6, sizeof(struct sockaddr_in6));
if(dstlen)
*dstlen=sizeof(struct sockaddr_in6);
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
return 0;
}
int sockaddr_to_inet(struct sockaddr *ip, inet_prefix *dst, u_short *port)
{
u_short po;
char *p;
setzero(dst, sizeof(inet_prefix));
dst->family=ip->sa_family;
memcpy(&po, &ip->sa_data, sizeof(u_short));
if(port)
*port=ntohs(po);
if(ip->sa_family==AF_INET)
p=(char *)ip->sa_data+sizeof(u_short);
else if(ip->sa_family==AF_INET6)
p=(char *)ip->sa_data+sizeof(u_short)+sizeof(int);
else {
error(ERROR_MSG "family not supported", ERROR_POS);
return -1;
}
inet_setip(dst, (u_int *)p, ip->sa_family);
return 0;
}
/*\
*
* * * Socket operations * *
*
\*/
int new_socket(int sock_type)
{
int sockfd;
if((sockfd=socket(sock_type, SOCK_STREAM, 0)) == -1 ) {
error("Socket SOCK_STREAM creation failed: %s", strerror(errno));
return -1;
}
return sockfd;
}
int new_dgram_socket(int sock_type)
{
int sockfd;
if((sockfd=socket(sock_type, SOCK_DGRAM, 0)) == -1 ) {
error("Socket SOCK_DGRAM creation failed: %s", strerror(errno));
return -1;
}
return sockfd;
}
/*
* inet_close
*
* It closes the `*sk' socket and sets it to zero.
* It always returns 0;
*/
int inet_close(int *sk)
{
close(*sk);
return (*sk=0);
}
int inet_getpeername(int sk, inet_prefix *ip, short *port)
{
struct sockaddr_storage saddr_sto;
struct sockaddr *sa=(struct sockaddr *)&saddr_sto;
socklen_t alen;
alen = sizeof(saddr_sto);
setzero(sa, alen);
if(getpeername(sk, sa, &alen) == -1) {
error("Cannot getpeername: %s", strerror(errno));
return -1;
}
return sockaddr_to_inet(sa, ip, port);
}
/*
* join_ipv6_multicast: It adds the membership to the IPV6_ADDR_BROADCAST
* multicast group. The device with index `idx' will be used.
*/
int join_ipv6_multicast(int socket, int idx)
{
struct ipv6_mreq mreq6;
const int addr[MAX_IP_INT]=IPV6_ADDR_BROADCAST;
setzero(&mreq6, sizeof(struct ipv6_mreq));
memcpy(&mreq6.ipv6mr_multiaddr, addr, sizeof(struct in6_addr));
mreq6.ipv6mr_interface=idx;
if(setsockopt(socket, IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq6,
sizeof(mreq6)) < 0) {
error("Cannot set IPV6_JOIN_GROUP: %s", strerror(errno));
close(socket);
return -1;
}
return socket;
}
int set_multicast_if(int socket, int idx)
{
/* man ipv6 */
if (setsockopt(socket, IPPROTO_IPV6, IPV6_MULTICAST_IF,
&idx, sizeof(int)) < 0) {
error("set_multicast_if(): cannot set IPV6_MULTICAST_IF: %s",
strerror(errno));
close(socket);
return -1;
}
return 0;
}
int set_nonblock_sk(int fd)
{
if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
error("set_nonblock_sk(): cannot set O_NONBLOCK: %s",
strerror(errno));
close(fd);
return -1;
}
return 0;
}
int unset_nonblock_sk(int fd)
{
if (fcntl(fd, F_SETFL, 0) < 0) {
error("unset_nonblock_sk(): cannot unset O_NONBLOCK: %s",
strerror(errno));
close(fd);
return -1;
}
return 0;
}
int set_reuseaddr_sk(int socket)
{
int reuseaddr=1, ret;
/*
* SO_REUSEADDR: <<Go ahead and reuse that port even if it is in
* TIME_WAIT state.>>
*/
ret=setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(int));
if(ret < 0)
error("setsockopt SO_REUSEADDR: %s", strerror(errno));
return ret;
}
int set_bindtodevice_sk(int socket, char *dev)
{
struct ifreq ifr;
int ret=0;
setzero(&ifr, sizeof(ifr));
strncpy(ifr.ifr_name, dev, IFNAMSIZ-1);
ret=setsockopt(socket, SOL_SOCKET, SO_BINDTODEVICE, dev, strlen(dev)+1);
if(ret < 0)
error("setsockopt SO_BINDTODEVICE: %s", strerror(errno));
return ret;
}
/*
* `loop': 0 = disable, 1 = enable (default)
*/
int set_multicast_loop_sk(int family, int socket, u_char loop)
{
int ret=0;
/*
* <<The IPV6_MULTICAST_LOOP option gives the sender explicit control
* over whether or not subsequent datagrams are looped bac.>>
*/
if(family==AF_INET6)
ret=setsockopt(socket, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &loop, sizeof(loop));
if(ret < 0)
error("setsockopt IP_MULTICAST_LOOP: %s", strerror(errno));
return ret;
}
int set_broadcast_sk(int socket, int family, inet_prefix *host, short port,
int dev_idx)
{
struct sockaddr_storage saddr_sto;
struct sockaddr *sa=(struct sockaddr *)&saddr_sto;
socklen_t alen;
int broadcast=1;
if(family == AF_INET) {
if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, &broadcast,
sizeof(broadcast)) < 0) {
error("Cannot set SO_BROADCAST to socket: %s", strerror(errno));
close(socket);
return -1;
}
} else if(family == AF_INET6) {
if(join_ipv6_multicast(socket, dev_idx) < 0)
return -1;
if(set_multicast_loop_sk(family, socket, 0) < 0)
return -1;
set_multicast_if(socket, dev_idx);
} else
fatal(ERROR_MSG "family not supported", ERROR_POS);
/* What's my name ? */
alen = sizeof(saddr_sto);
setzero(sa, alen);
if (getsockname(socket, sa, &alen) == -1) {
error("Cannot getsockname: %s", strerror(errno));
close(socket);
return -1;
}
/* Let's bind it! */
if(bind(socket, sa, alen) < 0) {
error("Cannot bind the broadcast socket: %s", strerror(errno));
close(socket);
return -1;
}
return socket;
}
int unset_broadcast_sk(int socket, int family)
{
int broadcast=0;
if(family == AF_INET) {
if (setsockopt(socket, SOL_SOCKET, SO_BROADCAST, &broadcast, sizeof(broadcast)) < 0) {
error ("Cannot unset broadcasting: %s", strerror(errno));
return -1;
}
}
return 0;
}
int set_keepalive_sk(int socket)
{
int on=1;
if(setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, (void *)&on,
sizeof(on)) < 0){
error("Cannot set keepalive socket: %s", strerror(errno));
return -1;
}
return 0;
}
int unset_keepalive_sk(int socket)
{
int off=0;
if(setsockopt(socket, SOL_SOCKET, SO_KEEPALIVE, (void *)&off,
sizeof(off)) < 0){
error("Cannot unset keepalive socket: %s", strerror(errno));
return -1;
}
return 0;
}
int set_tos_sk(int socket, int lowdelay)
{
int tos = lowdelay ? IPTOS_LOWDELAY : IPTOS_THROUGHPUT;
/* Only for Ipv4 */
if (setsockopt(socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
error("setsockopt IP_TOS %d: %s", tos, strerror(errno));
return -1;
}
return 0;
}
/*\
*
* * * Connection functions * *
*
\*/
int new_tcp_conn(inet_prefix *host, short port, char *dev)
{
int sk;
socklen_t sa_len;
struct sockaddr_storage saddr_sto;
struct sockaddr *sa=(struct sockaddr *)&saddr_sto;
const char *ntop;
ntop=inet_to_str(*host);
if(inet_to_sockaddr(host, port, sa, &sa_len)) {
error("Cannot new_tcp_connect(): %d Family not supported", host->family);
ERROR_FINISH(sk, -1, finish);
}
if((sk = new_socket(host->family)) == -1)
ERROR_FINISH(sk, -1, finish);
if(dev) /* if `dev' is not null bind the socket to it */
if(set_bindtodevice_sk(sk, dev) < 0)
ERROR_FINISH(sk, -1, finish);
if (connect(sk, sa, sa_len) == -1) {
error("Cannot tcp_connect() to %s: %s", ntop, strerror(errno));
ERROR_FINISH(sk, -1, finish);
}
finish:
return sk;
}
int new_udp_conn(inet_prefix *host, short port, char *dev)
{
int sk;
socklen_t sa_len;
struct sockaddr_storage saddr_sto;
struct sockaddr *sa=(struct sockaddr *)&saddr_sto;
const char *ntop;
ntop=inet_to_str(*host);
if(inet_to_sockaddr(host, port, sa, &sa_len)) {
error("Cannot new_udp_connect(): %d Family not supported", host->family);
ERROR_FINISH(sk, -1, finish);
}
if((sk = new_dgram_socket(host->family)) == -1)
ERROR_FINISH(sk, -1, finish);
if(dev) /* if `dev' is not null bind the socket to it */
if(set_bindtodevice_sk(sk, dev) < 0)
ERROR_FINISH(sk, -1, finish);
if (connect(sk, sa, sa_len) == -1) {
error("Cannot connect to %s: %s", ntop, strerror(errno));
ERROR_FINISH(sk, -1, finish);
}
finish:
return sk;
}
int new_bcast_conn(inet_prefix *host, short port, int dev_idx)
{
struct sockaddr_storage saddr_sto;
struct sockaddr *sa=(struct sockaddr *)&saddr_sto;
socklen_t alen;
int sk;
const char *ntop;
if((sk = new_dgram_socket(host->family)) == -1)
return -1;
sk=set_broadcast_sk(sk, host->family, host, port, dev_idx);
/*
* Connect
*/
if(inet_to_sockaddr(host, port, sa, &alen)) {
error("set_broadcast_sk: %d Family not supported", host->family);
return -1;
}
if(host->family == AF_INET6) {
struct sockaddr_in6 *sin6=(struct sockaddr_in6 *)sa;
sin6->sin6_scope_id = dev_idx;
}
if(set_bindtodevice_sk(sk, (char *)ll_index_to_name(dev_idx)) < 0)
return -1;
if(connect(sk, sa, alen) == -1) {
ntop=inet_to_str(*host);
error("Cannot connect to the broadcast (%s): %s", ntop,
strerror(errno));
return -1;
}
return sk;
}
/*\
*
* * * Recv/Send functions * *
*
\*/
ssize_t inet_recv(int s, void *buf, size_t len, int flags)
{
ssize_t err;
fd_set fdset;
int ret;
if((err=recv(s, buf, len, flags))==-1) {
switch(errno)
{
default:
/* Probably connection was closed */
debug(DBG_NORMAL, "inet_recv: Cannot recv(): %s",
strerror(errno));
return err;
break;
}
}
return err;
}
/*
* inet_recv_timeout
*
* is the same as inet_recv() but if no reply is received for `timeout'
* seconds it returns -1.
*/
ssize_t inet_recv_timeout(int s, void *buf, size_t len, int flags, u_int timeout)
{
struct timeval timeout_t;
fd_set fdset;
int ret;
MILLISEC_TO_TV(timeout*1000, timeout_t);
FD_ZERO(&fdset);
FD_SET(s, &fdset);
ret = select(s+1, &fdset, NULL, NULL, &timeout_t);
if (ret == -1) {
error(ERROR_MSG "select error: %s", ERROR_FUNC, strerror(errno));
return ret;
}
return FD_ISSET(s, &fdset) ? inet_recv(s, buf, len, flags) : -1;
}
ssize_t inet_recvfrom(int s, void *buf, size_t len, int flags, struct sockaddr *from, socklen_t *fromlen)
{
ssize_t err;
fd_set fdset;
int ret;
if((err=recvfrom(s, buf, len, flags, from, fromlen)) < 0) {
switch(errno)
{
default:
error("inet_recvfrom: Cannot recv(): %s", strerror(errno));
return err;
break;
}
}
return err;
}
/*
* inet_recvfrom_timeout: is the same as inet_recvfrom() but if no reply is
* received for `timeout' seconds it returns -1.
*/
ssize_t inet_recvfrom_timeout(int s, void *buf, size_t len, int flags,
struct sockaddr *from, socklen_t *fromlen, u_int timeout)
{
struct timeval timeout_t;
fd_set fdset;
int ret;
MILLISEC_TO_TV(timeout*1000, timeout_t);
FD_ZERO(&fdset);
FD_SET(s, &fdset);
ret = select(s+1, &fdset, NULL, NULL, &timeout_t);
if (ret == -1) {
error(ERROR_MSG "select error: %s", ERROR_FUNC, strerror(errno));
return ret;
}
if(FD_ISSET(s, &fdset))
return inet_recvfrom(s, buf, len, flags, from, fromlen);
return -1;
}
ssize_t inet_send(int s, const void *msg, size_t len, int flags)
{
ssize_t err;
fd_set fdset;
int ret;
if((err=send(s, msg, len, flags)) < 0) {
switch(errno)
{
case EMSGSIZE:
inet_send(s, msg, len/2, flags);
err=inet_send(s, (const char *)msg+(len/2),
len-(len/2), flags);
break;
default:
error("inet_send: Cannot send(): %s", strerror(errno));
return err;
break;
}
}
return err;
}
/*
* inet_send_timeout: is the same as inet_send() but if the packet isn't sent
* in `timeout' seconds it timeouts and returns -1.
*/
ssize_t inet_send_timeout(int s, const void *msg, size_t len, int flags, u_int timeout)
{
struct timeval timeout_t;
fd_set fdset;
int ret;
MILLISEC_TO_TV(timeout*1000, timeout_t);
FD_ZERO(&fdset);
FD_SET(s, &fdset);
ret = select(s+1, NULL, &fdset, NULL, &timeout_t);
if (ret == -1) {
error(ERROR_MSG "select error: %s", ERROR_FUNC, strerror(errno));
return ret;
}
if(FD_ISSET(s, &fdset))
return inet_send(s, msg, len, flags);
return -1;
}
ssize_t inet_sendto(int s, const void *msg, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen)
{
ssize_t err;
fd_set fdset;
int ret;
if((err=sendto(s, msg, len, flags, to, tolen))==-1) {
error("sendto errno: %d err is: %d", errno, err);
switch(errno)
{
case EMSGSIZE:
error("Packet artificially fragmented: %d", stderr);
error("\nData Length: %u", len);
int bytesleft = len;
int sendbuf;
socklen_t optlen;
optlen = sizeof(sendbuf);
int res = getsockopt(s, SOL_SOCKET, SO_SNDBUF, &sendbuf, &optlen);
error("GetSockOpt: %i \n", res);
while(bytesleft != 0) {
if(bytesleft > 64000) {
inet_sendto(s, msg, 64000, flags, to, tolen);
bytesleft -= 64000;
msg += 64000;
//err=inet_sendto(s, ((const char *)msg+(len/2)),
//len-(len/2), flags, to, tolen);
}
else {
err=inet_sendto(s, msg, bytesleft, flags, to, tolen);
bytesleft = 0;
}
}
break;
case EFAULT:
error("The value of to is: %d", to);
default:
error("inet_sendto: Cannot send(): %s", strerror(errno));
return err;
break;
}
}
return err;
}
/*
* inet_sendto_timeout: is the same as inet_sendto() but if the packet isn't sent
* in `timeout' seconds it timeouts and returns -1.
*/
ssize_t inet_sendto_timeout(int s, const void *msg, size_t len, int flags,
const struct sockaddr *to, socklen_t tolen, u_int timeout)
{
struct timeval timeout_t;
fd_set fdset;
int ret;
MILLISEC_TO_TV(timeout*1000, timeout_t);
FD_ZERO(&fdset);
FD_SET(s, &fdset);
ret = select(s+1, NULL, &fdset, NULL, &timeout_t);
if (ret == -1) {
error(ERROR_MSG "select error: %s", ERROR_FUNC, strerror(errno));
return ret;
}
if(FD_ISSET(s, &fdset))
return inet_sendto(s, msg, len, flags, to, tolen);
return -1;
}
ssize_t inet_sendfile(int out_fd, int in_fd, off_t *offset, size_t count)
{
ssize_t err;
fd_set fdset;
int ret;
if((err=sendfile(out_fd, in_fd, offset, count))==-1)
error("inet_sendfile: Cannot sendfile(): %s", strerror(errno));
return err;
}
Reference in New Issue View Git Blame Copy Permalink