int SetGateway(int fd, char *pcInterface, unsigned long ulIP)
{
//struct rtentry rItem;
struct ecos_rtentry rItem;
//int fd;
unsigned ulOldGateway;
int rt;
//if ((fd = socket(AF_INET,SOCK_DGRAM,0)) < 0) return FALSE;
memset(&rItem, 0, sizeof(rItem));
set_sockaddr((struct sockaddr_in *) &rItem.rt_dst, inet_addr("10.130.0.0"), 0);
set_sockaddr((struct sockaddr_in *) &rItem.rt_genmask, inet_addr("255.255.0.0"), 0);
rItem.rt_flags = RTF_UP;// | RTF_HOST;//RTF_GATEWAY;
rItem.rt_dev = pcInterface;
set_sockaddr((struct sockaddr_in *) &rItem.rt_gateway, ulIP, 0);
if ((rt = ioctl(fd,SIOCADDRT, &rItem)) < 0)
{
fprintf(stderr, "Cannot add default route (%d).\n", errno);
}
//close(fd);
return (rt < 0 ? FALSE : TRUE);
}
bool HHVM_FUNCTION(socket_bind,
const Resource& socket,
const String& address,
int port /* = 0 */) {
auto sock = cast<Socket>(socket);
const char *addr = address.data();
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, addr, port, sa_ptr, sa_size)) {
return false;
}
long retval = ::bind(sock->fd(), sa_ptr, sa_size);
if (retval != 0) {
std::string msg = "unable to bind address";
msg += addr;
msg += ":";
msg += folly::to<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), errno);
return false;
}
return true;
}
Variant socket_server_impl(
const HostURL &hosturl,
int flags, /* = STREAM_SERVER_BIND|STREAM_SERVER_LISTEN */
VRefParam errnum /* = null */,
VRefParam errstr /* = null */
) {
errnum = 0;
errstr = empty_string();
auto sock = create_new_socket(hosturl, errnum, errstr);
if (!sock) {
return false;
}
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, hosturl.getHost().c_str(),
hosturl.getPort(), sa_ptr, sa_size)) {
return false;
}
int yes = 1;
setsockopt(sock->fd(), SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes));
if ((flags & k_STREAM_SERVER_BIND) != 0 &&
::bind(sock->fd(), sa_ptr, sa_size) < 0) {
SOCKET_ERROR(sock, "unable to bind to given address", errno);
return false;
}
if ((flags & k_STREAM_SERVER_LISTEN) != 0 && listen(sock->fd(), 128) < 0) {
SOCKET_ERROR(sock, "unable to listen on socket", errno);
return false;
}
return Variant(std::move(sock));
}
Variant f_socket_server(CStrRef hostname, int port /* = -1 */,
VRefParam errnum /* = null */,
VRefParam errstr /* = null */) {
Object ret;
Socket *sock = NULL;
const char *name = hostname.data();
if (!create_new_socket(name, port, errnum, errstr, ret, sock, 0.0)) {
return false;
}
assert(ret.get() && sock);
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, name, port, sa_ptr, sa_size)) {
return false;
}
if (::bind(sock->fd(), sa_ptr, sa_size) < 0) {
SOCKET_ERROR(sock, "unable to bind to given adress", errno);
return false;
}
if (listen(sock->fd(), 128) < 0) {
SOCKET_ERROR(sock, "unable to listen on socket", errno);
return false;
}
return ret;
}
/*
* Get a file handle from the server for the directory which is to be
* mounted.
*/
static int __init root_nfs_get_handle(void)
{
struct sockaddr_in sin;
unsigned int auth_flav_len = 0;
struct nfs_mount_request request = {
.sap = (struct sockaddr *)&sin,
.salen = sizeof(sin),
.dirpath = nfs_export_path,
.version = (nfs_data.flags & NFS_MOUNT_VER3) ?
NFS_MNT3_VERSION : NFS_MNT_VERSION,
.protocol = (nfs_data.flags & NFS_MOUNT_TCP) ?
XPRT_TRANSPORT_TCP : XPRT_TRANSPORT_UDP,
.auth_flav_len = &auth_flav_len,
};
int status = -ENOMEM;
request.fh = nfs_alloc_fhandle();
if (!request.fh)
goto out;
set_sockaddr(&sin, servaddr, htons(mount_port));
status = nfs_mount(&request);
if (status < 0)
printk(KERN_ERR "Root-NFS: Server returned error %d "
"while mounting %s\n", status, nfs_export_path);
else {
nfs_data.root.size = request.fh->size;
memcpy(&nfs_data.root.data, request.fh->data, request.fh->size);
}
nfs_free_fhandle(request.fh);
out:
return status;
}
/*
* Get the NFS port numbers and file handle, and return the prepared 'data'
* argument for mount() if everything went OK. Return NULL otherwise.
*/
void * __init nfs_root_data(void)
{
if (root_nfs_init() < 0
|| root_nfs_ports() < 0
|| root_nfs_get_handle() < 0)
return NULL;
set_sockaddr((struct sockaddr_in *) &nfs_data.addr, servaddr, htons(nfs_port));
return (void*)&nfs_data;
}
/*
* Query server portmapper for the port of a daemon program.
*/
static int __init root_nfs_getport(int program, int version, int proto)
{
struct sockaddr_in sin;
printk(KERN_NOTICE "Looking up port of RPC %d/%d on %u.%u.%u.%u\n",
program, version, NIPQUAD(servaddr));
set_sockaddr(&sin, servaddr, 0);
return rpc_getport_external(&sin, program, version, proto);
}
/*
* Get the NFS port numbers and file handle, and return the prepared 'data'
* argument for ->read_super() if everything went OK. Return NULL otherwise.
*/
void * __init nfs_root_data(void)
{
if (root_nfs_init() < 0
|| root_nfs_ports() < 0
|| root_nfs_get_handle() < 0)
return NULL;
set_sockaddr((struct sockaddr_in *) &nfs_data.addr, servaddr, nfs_port);
return (void*)&nfs_data;
}
/*
* Query server portmapper for the port of a daemon program.
*/
static int __init root_nfs_getport(int program, int version, int proto)
{
struct sockaddr_in sin;
printk(KERN_NOTICE "Looking up port of RPC %d/%d on %pI4\n",
program, version, &servaddr);
set_sockaddr(&sin, servaddr, 0);
return rpcb_getport_sync(&sin, program, version, proto);
}
int lkl_set_ipv4_gateway(unsigned int addr)
{
struct lkl_rtentry re;
int err, sock = lkl_sys_socket(LKL_AF_INET, LKL_SOCK_DGRAM, 0);
if (sock < 0)
return sock;
memset(&re, 0, sizeof(re));
set_sockaddr((struct lkl_sockaddr_in *) &re.rt_dst, 0, 0);
set_sockaddr((struct lkl_sockaddr_in *) &re.rt_genmask, 0, 0);
set_sockaddr((struct lkl_sockaddr_in *) &re.rt_gateway, addr, 0);
re.rt_flags = LKL_RTF_UP | LKL_RTF_GATEWAY;
err = lkl_sys_ioctl(sock, LKL_SIOCADDRT, (long)&re);
lkl_sys_close(sock);
return err;
}
int lkl_if_set_ipv4(int ifindex, unsigned int addr, unsigned int netmask_len)
{
struct lkl_ifreq ifr;
struct lkl_sockaddr_in *sin;
int err, sock;
sock = lkl_sys_socket(LKL_AF_INET, LKL_SOCK_DGRAM, 0);
if (sock < 0)
return sock;
err = ifindex_to_name(sock, &ifr, ifindex);
if (err < 0)
return err;
if (netmask_len >= 31)
return -LKL_EINVAL;
sin = (struct lkl_sockaddr_in *)&ifr.lkl_ifr_addr;
set_sockaddr(sin, addr, 0);
err = lkl_sys_ioctl(sock, LKL_SIOCSIFADDR, (long)&ifr);
if (!err) {
int netmask = (((1<<netmask_len)-1))<<(32-netmask_len);
sin = (struct lkl_sockaddr_in *)&ifr.lkl_ifr_netmask;
set_sockaddr(sin, htonl(netmask), 0);
err = lkl_sys_ioctl(sock, LKL_SIOCSIFNETMASK, (long)&ifr);
if (!err) {
set_sockaddr(sin, htonl(ntohl(addr)|~netmask), 0);
err = lkl_sys_ioctl(sock, LKL_SIOCSIFBRDADDR, (long)&ifr);
}
}
lkl_sys_close(sock);
return err;
}
/*
* Get a file handle from the server for the directory which is to be
* mounted.
*/
static int __init root_nfs_get_handle(void)
{
struct sockaddr_in sin;
int status;
int protocol = (nfs_data.flags & NFS_MOUNT_TCP) ?
IPPROTO_TCP : IPPROTO_UDP;
int version = (nfs_data.flags & NFS_MOUNT_VER3) ?
NFS_MNT3_VERSION : NFS_MNT_VERSION;
set_sockaddr(&sin, servaddr, mount_port);
status = nfsroot_mount(&sin, nfs_path, &nfs_data.root,
version, protocol);
if (status < 0)
printk(KERN_ERR "Root-NFS: Server returned error %d "
"while mounting %s\n", status, nfs_path);
return status;
}
bool HHVM_FUNCTION(socket_connect,
const Resource& socket,
const String& address,
int port /* = 0 */) {
auto sock = cast<Socket>(socket);
switch (sock->getType()) {
case AF_INET6:
case AF_INET:
if (port == 0) {
raise_warning("Socket of type AF_INET/6 requires 3 arguments");
return false;
}
break;
default:
break;
}
const char *addr = address.data();
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, addr, port, sa_ptr, sa_size)) {
return false;
}
IOStatusHelper io("socket::connect", address.data(), port);
int retval = connect(sock->fd(), sa_ptr, sa_size);
if (retval != 0) {
std::string msg = "unable to connect to ";
msg += addr;
msg += ":";
msg += folly::to<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), errno);
return false;
}
return true;
}
/*
* Get a file handle from the server for the directory which is to be
* mounted.
*/
static int __init root_nfs_get_handle(void)
{
struct nfs_fh fh;
struct sockaddr_in sin;
int status;
int protocol = (nfs_data.flags & NFS_MOUNT_TCP) ?
XPRT_TRANSPORT_TCP : XPRT_TRANSPORT_UDP;
int version = (nfs_data.flags & NFS_MOUNT_VER3) ?
NFS_MNT3_VERSION : NFS_MNT_VERSION;
set_sockaddr(&sin, servaddr, htons(mount_port));
status = nfs_mount((struct sockaddr *) &sin, sizeof(sin), NULL,
nfs_path, version, protocol, &fh, nfs_data.mount_prog);
if (status < 0)
printk(KERN_ERR "Root-NFS: Server returned error %d "
"while mounting %s\n", status, nfs_path);
else {
nfs_data.root.size = fh.size;
memcpy(nfs_data.root.data, fh.data, fh.size);
}
return status;
}
bool f_socket_bind(CObjRef socket, CStrRef address, int port /* = 0 */) {
Socket *sock = socket.getTyped<Socket>();
const char *addr = address.data();
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, addr, port, sa_ptr, sa_size)) {
return false;
}
long retval = ::bind(sock->fd(), sa_ptr, sa_size);
if (retval != 0) {
std::string msg = "unable to bind address";
msg += addr;
msg += ":";
msg += boost::lexical_cast<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), errno);
return false;
}
return true;
}
int main(void){
int s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
assert(s != -1);
struct sockaddr_in servo_ctl;
set_sockaddr((struct sockaddr*)&servo_ctl, "10.0.0.30", 35003);
if (connect(s, (struct sockaddr *)&servo_ctl, sizeof(servo_ctl))) {
printf("Could not connect to servo board! errno: %i\n", errno);
return errno;
} else {
printf("Connected to servo control board!\n");
}
seq_socket_init(&sock, s);
struct timespec sleeptime;
int pulsewidth;
for(;;) {
sleeptime.tv_sec = 0;
sleeptime.tv_nsec = 25000000; /* 25 mS */
for (pulsewidth = 1100; pulsewidth <= 1900; pulsewidth += 10) {
sendpwm(pulsewidth, 0);
nanosleep(&sleeptime, NULL);
}
for (pulsewidth = 1900; pulsewidth >= 1100; pulsewidth -= 10) {
sendpwm(pulsewidth, 0);
nanosleep(&sleeptime, NULL);
}
sleeptime.tv_sec = 4;
sleeptime.tv_nsec = 25000000; /* 25 mS */
sendpwm(1500, 1);
nanosleep(&sleeptime, NULL);
}
}
bool f_socket_connect(CObjRef socket, CStrRef address, int port /* = 0 */) {
Socket *sock = socket.getTyped<Socket>();
switch (sock->getType()) {
case AF_INET6:
case AF_INET:
if (port == 0) {
raise_warning("Socket of type AF_INET/6 requires 3 arguments");
return false;
}
break;
default:
break;
}
const char *addr = address.data();
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, addr, port, sa_ptr, sa_size)) {
return false;
}
IOStatusHelper io("socket::connect", address.data(), port);
int retval = connect(sock->fd(), sa_ptr, sa_size);
if (retval != 0) {
std::string msg = "unable to connect to ";
msg += addr;
msg += ":";
msg += boost::lexical_cast<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), errno);
return false;
}
return true;
}
void test_netioctl_withbuf_entry(char *pBuf, int iBufLen)
{
struct rtentry rtitem;
int dst, mask, gateway;
int i, fd;
fd = socket(AF_INET, SOCK_DGRAM, 0, pBuf, iBufLen);
if(fd < 0)
{
test_printf_error("test_netioctl_withbuf_entry");
return;
}
memset(&rtitem, 0, sizeof(rtitem));
if(inet_aton(TEST_NETIOCTL_WITH_BUF_DST, (struct in_addr*)&dst, pBuf, iBufLen) == 0)
{
test_printf_error("test_netioctl_withbuf_entry");
netclose(fd, pBuf, iBufLen);
return;
}
if(inet_aton(TEST_NETIOCTL_WITH_BUF_MASK, (struct in_addr*)&mask, pBuf, iBufLen) == 0)
{
test_printf_error("test_netioctl_withbuf_entry");
netclose(fd, pBuf, iBufLen);
return;
}
if(inet_aton(TEST_NETIOCTL_WITH_BUF_GATEWAY, (struct in_addr*)&gateway, pBuf, iBufLen) == 0)
{
test_printf_error("test_netioctl_withbuf_entry");
netclose(fd, pBuf, iBufLen);
return;
}
set_sockaddr((struct sockaddr_in *) &rtitem.rt_dst, dst, 0);
set_sockaddr((struct sockaddr_in *) &rtitem.rt_genmask, mask, 0);
set_sockaddr((struct sockaddr_in *) &rtitem.rt_gateway, gateway, 0);
rtitem.rt_flags = RTF_UP | RTF_GATEWAY;
rtitem.rt_dev = "eth1";
if(netioctl_withbuf(fd, SIOCDELRT, &rtitem, sizeof(rtitem), pBuf, iBufLen) < 0)
{
test_printf_error("test_netioctl_withbuf_entry");
netclose(fd, pBuf, iBufLen);
return;
}
/*
printf("To check with \"route\" command in 5 seconds");
for(i = 0; i < 10; i++)
{
printf(".");
tt_msleep(1000);
}
printf("\n");
*/
if(netioctl_withbuf(fd, SIOCADDRT, &rtitem,sizeof(rtitem), pBuf, iBufLen) < 0)
{
test_printf_error("test_netioctl_withbuf_entry");
netclose(fd, pBuf, iBufLen);
return;
}
test_printf_success("test_netioctl_withbuf_entry");
netclose(fd, pBuf, iBufLen);
}
BOOL SetGateway(const char *pcInterface, unsigned long ulIP)
{
#ifndef WLAN
struct rtentry rItem;
#else
struct ecos_rtentry rItem;
#endif
int fd;
unsigned ulOldGateway;
int rt;
#ifndef WLAN
if ((fd = socket(AF_INET,SOCK_DGRAM,0, g_StreamServer_Buf, System_BUFFER_LEN)) < 0)
return FALSE;
#else
if ((fd = socket(AF_INET,SOCK_DGRAM,0)) < 0)
return FALSE;
#endif
memset(&rItem, 0, sizeof(rItem));
#ifndef WLAN
set_sockaddr((struct sockaddr_in *) &rItem.rt_dst, 0, 0);
set_sockaddr((struct sockaddr_in *) &rItem.rt_genmask, 0, 0);
rItem.rt_flags = RTF_UP | RTF_GATEWAY;
#else
set_sockaddr((struct sockaddr_in *) &rItem.rt_dst, 0, 0);
set_sockaddr((struct sockaddr_in *) &rItem.rt_genmask, 0, 0);
rItem.rt_flags = RTF_UP| RTF_GATEWAY;
#endif
rItem.rt_dev = (char *)pcInterface;
ulOldGateway = GetGateway(pcInterface);
#ifndef WLAN
if (ulOldGateway != 0L)
{
set_sockaddr((struct sockaddr_in *)&rItem.rt_gateway, ulOldGateway, 0);
if ((netioctl_withbuf(fd, SIOCDELRT, &rItem , sizeof(rItem), g_StreamServer_Buf, System_BUFFER_LEN)) < 0)
fprintf(stderr, "Cannot del default route (%d).\n", errno);
}
set_sockaddr((struct sockaddr_in *) &rItem.rt_gateway, ulIP, 0);
if ((rt = netioctl_withbuf(fd,SIOCADDRT, &rItem, sizeof(rItem),g_StreamServer_Buf,System_BUFFER_LEN)) < 0)
{
fprintf(stderr, "Cannot add default route (%d).\n", errno);
}
netclose(fd, g_StreamServer_Buf, System_BUFFER_LEN);
#else
set_sockaddr((struct sockaddr_in *) &rItem.rt_gateway, ulIP, 0);
if ((rt = ioctl(fd,SIOCDELRT, &rItem)) < 0 && (errno != ESRCH))
{
fprintf(stderr, "Cannot delete default route (%d).\n", errno);
}
memset(&rItem, 0, sizeof(rItem));
set_sockaddr((struct sockaddr_in *) &rItem.rt_dst, 0, 0);
set_sockaddr((struct sockaddr_in *) &rItem.rt_genmask, 0, 0);
rItem.rt_flags = RTF_UP | RTF_GATEWAY;
rItem.rt_dev = (char *)pcInterface;
set_sockaddr((struct sockaddr_in *) &rItem.rt_gateway, ulIP, 0);
if ((rt = ioctl(fd,SIOCADDRT, &rItem)) < 0)
{
fprintf(stderr, "Cannot add default route (%d).\n", errno);
}
close(fd);
#endif
return (rt < 0 ? FALSE : TRUE);
}
static Variant new_socket_connect(const HostURL &hosturl, double timeout,
Variant &errnum, Variant &errstr) {
int domain = AF_UNSPEC;
int type = SOCK_STREAM;
auto const& scheme = hosturl.getScheme();
SmartPtr<Socket> sock;
SmartPtr<SSLSocket> sslsock;
std::string sockerr;
int error;
if (scheme == "udp" || scheme == "udg") {
type = SOCK_DGRAM;
} else if (scheme == "unix") {
domain = AF_UNIX;
}
int fd = -1;
if (domain == AF_UNIX) {
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
fd = socket(domain, type, 0);
sock = makeSmartPtr<Socket>(
fd, domain, hosturl.getHost().c_str(), hosturl.getPort());
if (!set_sockaddr(sa_storage, sock, hosturl.getHost().c_str(),
hosturl.getPort(), sa_ptr, sa_size)) {
// set_sockaddr raises its own warning on failure
return false;
}
if (connect_with_timeout(fd, sa_ptr, sa_size, timeout,
hosturl, sockerr, error) != 0) {
SOCKET_ERROR(sock, sockerr.c_str(), error);
errnum = sock->getLastError();
errstr = HHVM_FN(socket_strerror)(sock->getLastError());
return false;
}
} else {
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = domain;
hints.ai_socktype = type;
auto port = folly::to<std::string>(hosturl.getPort());
auto host = hosturl.getHost();
struct addrinfo *aiHead;
int errcode = getaddrinfo(host.c_str(), port.c_str(), &hints, &aiHead);
if (errcode != 0) {
errstr = String(gai_strerror(errcode), CopyString);
return false;
}
SCOPE_EXIT { freeaddrinfo(aiHead); };
for (struct addrinfo *ai = aiHead; ai != nullptr; ai = ai->ai_next) {
domain = ai->ai_family;
fd = socket(domain, ai->ai_socktype, ai->ai_protocol);
if (fd == -1) {
continue;
}
if (connect_with_timeout(fd, ai->ai_addr, ai->ai_addrlen, timeout,
hosturl, sockerr, error) == 0) {
break;
}
close(fd);
fd = -1;
}
sslsock = SSLSocket::Create(fd, domain, hosturl, timeout);
if (sslsock) {
sock = sslsock;
} else {
sock = makeSmartPtr<Socket>(fd,
domain,
hosturl.getHost().c_str(),
hosturl.getPort());
}
}
if (!sock->valid()) {
SOCKET_ERROR(sock,
sockerr.empty() ? "unable to create socket" : sockerr.c_str(), error);
errnum = sock->getLastError();
errstr = HHVM_FN(socket_strerror)(sock->getLastError());
return false;
}
if (sslsock && !sslsock->onConnect()) {
raise_warning("Failed to enable crypto");
return false;
}
return Variant(std::move(sock));
}
static msg_t rci_thread(void *p){
chRegSetThreadName("RCI");
struct RCICommand * commands = (struct RCICommand *)p;
struct sockaddr from;
socklen_t fromlen;
struct sockaddr own;
set_sockaddr(&own, "0.0.0.0", 23);
char rx_buf[ETH_MTU];
char tx_buf[ETH_MTU];
int sock = socket(AF_INET, SOCK_STREAM, 0);
chDbgAssert(sock >= 0, "Could not get RCI socket", NULL);
int optval = 1;
socklen_t optlen = sizeof(optval);
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &optval, optlen);
if(bind(sock, &own, sizeof(struct sockaddr_in)) < 0){
perror("bind");
chDbgPanic("Could not bind RCI socket");
}
if(listen(sock, 1) < 0){
chDbgPanic("Could not listen on RCI socket");
}
while(TRUE) {
struct RCICmdData cmd = {
.name = NULL,
.data = rx_buf,
.len = 0,
};
struct RCIRetData ret = {
.data = tx_buf,
.len = 0,
};
fromlen = sizeof(from);
int s = ACCEPT(sock, &from, &fromlen);
if(s < 0){
continue;
}
cmd.len = get_command(s, rx_buf, sizeof(rx_buf));
if(cmd.len < 0){
close(s);
continue;
}
handle_command(&cmd, &ret, commands);
//if there's data to return, return it to the address it came from
send_response(s, ret.data, ret.len, sizeof(tx_buf));
close(s);
}
return -1;
}
void RCICreate(struct RCICommand * cmd){
chDbgAssert(cmd, "RCICreate needs a config", NULL);
#if 0 //FIXME: because of threads this doesn't actually work all the time.
// What's a better way of finding lwip has started.
/* Check if LWIP has been started */
Thread * thd = chRegFirstThread();
while(thd){
if(!strcmp("lwipthread", thd->p_name)){
break;
}
thd = chRegNextThread(thd);
}
chDbgAssert(thd, "RCICreate needs lwip started beforehand", NULL);
#endif
chThdCreateStatic(wa_rci, sizeof(wa_rci), NORMALPRIO, rci_thread, (void *)cmd);
}
static Variant sockopen_impl(CStrRef hostname, int port, Variant &errnum,
Variant &errstr, double timeout,
bool persistent) {
string key;
if (persistent) {
key = hostname.data();
key += ":";
key += boost::lexical_cast<string>(port);
Socket *sock =
dynamic_cast<Socket*>(g_persistentObjects->get("socket", key.c_str()));
if (sock) {
if (sock->getError() == 0 && sock->checkLiveness()) {
return Object(sock);
}
// socket had an error earlier, we need to remove it from persistent
// storage, and create a new one
g_persistentObjects->remove("socket", key.c_str());
}
}
Object ret;
const char *name = hostname.data();
Socket *sock = NULL;
if (timeout <= 0) timeout = RuntimeOption::SocketDefaultTimeout;
// test if protocol is SSL
SSLSocket *sslsock = SSLSocket::Create(name, port, timeout);
if (sslsock) {
sock = sslsock;
ret = sock;
} else if (!create_new_socket(name, port, errnum, errstr,
ret, sock, timeout)) {
return false;
}
assert(ret.get() && sock);
sockaddr_storage sa_storage;
struct sockaddr *sa_ptr;
size_t sa_size;
if (!set_sockaddr(sa_storage, sock, name, port, sa_ptr, sa_size)) {
return false;
}
int retval;
int fd = sock->fd();
IOStatusHelper io("socket::connect", name, port);
if (timeout <= 0) {
retval = connect(fd, sa_ptr, sa_size);
} else {
// set non-blocking so we can do timeouts
long arg = fcntl(fd, F_GETFL, NULL);
fcntl(fd, F_SETFL, arg | O_NONBLOCK);
retval = connect(fd, sa_ptr, sa_size);
if (retval < 0) {
if (errno == EINPROGRESS) {
struct pollfd fds[1];
fds[0].fd = fd;
fds[0].events = POLLOUT;
if (poll(fds, 1, (int)(timeout * 1000))) {
socklen_t lon = sizeof(int);
int valopt;
getsockopt(fd, SOL_SOCKET, SO_ERROR, (void*)(&valopt), &lon);
if (valopt) {
std::string msg = "failed to connect to ";
msg += name;
msg += ":";
msg += boost::lexical_cast<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), valopt);
errnum = sock->getError();
errstr = String(Util::safe_strerror(sock->getError()));
return false;
} else {
retval = 0; // success
}
} else {
std::string msg = "timed out after ";
msg += boost::lexical_cast<std::string>(timeout);
msg += " seconds when connecting to ";
msg += name;
msg += ":";
msg += boost::lexical_cast<std::string>(port);
SOCKET_ERROR(sock, msg.c_str(), ETIMEDOUT);
errnum = sock->getError();
errstr = String(Util::safe_strerror(sock->getError()));
return false;
}
}
}
// set to blocking mode
arg = fcntl(fd, F_GETFL, NULL);
fcntl(fd, F_SETFL, arg & ~O_NONBLOCK);
}
if (retval != 0) {
errnum = sock->getError();
errstr = String(Util::safe_strerror(sock->getError()));
return false;
}
if (sslsock && !sslsock->onConnect()) {
raise_warning("Failed to enable crypto");
return false;
}
if (persistent) {
assert(!key.empty());
g_persistentObjects->set("socket", key.c_str(), sock);
}
return ret;
}
int simple_ioctl_withbuf(void)
{
struct ifreq ifbuf[4]={0};
struct ifconf ifc;
int fd, ifnum=0;
memset(&ifc, 0, sizeof(ifc));
fd = socket(AF_INET, SOCK_DGRAM, 0, g_RemoteNet_Buf, RNT_BUFFER_LEN);
ifc.ifc_len = sizeof(ifbuf);
ifc.ifc_buf = (caddr_t)ifbuf;
if(netioctl_withbuf(fd, SIOCGIFCONF, &ifc,sizeof(ifc), g_RemoteNet_Buf, RNT_BUFFER_LEN) < 0)
{
printf("simple_ioctl_withbuf(): SIOCGIFCONF error\n");
return false;
}
for(ifnum = 0; ifnum < 4; ifnum++)
{
if(strlen(ifbuf[ifnum].ifr_name) != 0)
printf("simple_ioctl_withbuf(): SIOCGIFCONF's %d interface is %s\n", ifnum, ifbuf[ifnum].ifr_name);
}
{
struct rtentry rtitem;
int dst, mask, gateway;
memset(&rtitem, 0, sizeof(rtitem));
dst = inet_addr("0.0.0.0", g_RemoteNet_Buf, RNT_BUFFER_LEN);
mask = inet_addr("0.0.0.0", g_RemoteNet_Buf, RNT_BUFFER_LEN);
gateway = inet_addr("10.132.1.254", g_RemoteNet_Buf, RNT_BUFFER_LEN);
set_sockaddr((struct sockaddr_in *) &rtitem.rt_dst, 0, 0);
set_sockaddr((struct sockaddr_in *) &rtitem.rt_genmask, 0, 0);
set_sockaddr((struct sockaddr_in *) &rtitem.rt_gateway, gateway, 0);
rtitem.rt_flags = RTF_UP | RTF_GATEWAY;
rtitem.rt_dev = "eth1";
printf("dst=%s ", inet_ntoa(((struct sockaddr_in*)&(rtitem.rt_dst))->sin_addr, g_RemoteNet_Buf, RNT_BUFFER_LEN));
printf("mask=%s ", inet_ntoa(((struct sockaddr_in*)&(rtitem.rt_genmask))->sin_addr, g_RemoteNet_Buf, RNT_BUFFER_LEN));
printf("gateway=%s ", inet_ntoa(((struct sockaddr_in*)&(rtitem.rt_gateway))->sin_addr, g_RemoteNet_Buf, RNT_BUFFER_LEN));
printf("if=%s\n", rtitem.rt_dev);
if(netioctl_withbuf(fd, SIOCDELRT, &rtitem,sizeof(rtitem), g_RemoteNet_Buf, RNT_BUFFER_LEN) < 0)
{
printf("simple_ioctl_withbuf(): SIOCDELRT error\n");
return false;
}
printf("simple_ioctl_withbuf(): SIOCDELRT success...\n");
cyg_thread_delay(500);
if(netioctl_withbuf(fd, SIOCADDRT, &rtitem,sizeof(rtitem), g_RemoteNet_Buf, RNT_BUFFER_LEN) < 0)
{
printf("simple_ioctl_withbuf(): SIOCADDRT error\n");
return false;
}
printf("simple_ioctl_withbuf(): SIOCADDRT success...\n");
}
netclose(fd, g_RemoteNet_Buf, RNT_BUFFER_LEN);
return true;
}
bool set_lo_address(int fd)
{
struct ifreq ifr;
struct sockaddr_in *pAddr;
int rt;
/* Start lo */
strcpy(ifr.ifr_name, "lo0");
if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
diag_printf("get lo flags error\n");
}
else {
if(ifr.ifr_flags & IFF_UP) diag_printf("lo up\n");
if(ifr.ifr_flags & IFF_RUNNING) diag_printf("lo running\n");
}
ifr.ifr_flags = IFF_UP | IFF_RUNNING;
if (ioctl(fd, SIOCSIFFLAGS, &ifr) < 0) {
diag_printf("SIOCSIFFLAGS error %x\n", errno);
return false;
}
pAddr = (struct sockaddr_in *)&(ifr.ifr_addr);
bzero(pAddr, sizeof(struct sockaddr_in));
pAddr->sin_addr.s_addr = inet_addr("127.0.0.1");
pAddr->sin_family = AF_INET;
ioctl(fd, SIOCSIFADDR, &ifr);
//if (ioctl(fd, SIOCSIFADDR, &ifr) < 0)
//{
// fprintf(stderr,"Set lo Ip Address error\n");
//close(fd);
//return false;
//}
pAddr = (struct sockaddr_in *)&(ifr.ifr_addr);
bzero(pAddr, sizeof(struct sockaddr_in));
pAddr->sin_addr.s_addr = inet_addr("255.0.0.0");
pAddr->sin_family = AF_INET;
if (ioctl(fd, SIOCSIFNETMASK, &ifr) < 0)
{
fprintf(stderr,"Set lo netmask error\n");
close(fd);
return false;
}
// if (ioctl(fd, SIOCGIFADDR, &ifr) >= 0)
// diag_printf("ipaddr Address====%s\n",inet_ntoa(((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr));
{
struct ecos_rtentry rItem;
//int fd;
unsigned ulOldGateway;
//if ((fd = socket(AF_INET,SOCK_DGRAM,0)) < 0) return FALSE;
memset(&rItem, 0, sizeof(rItem));
set_sockaddr((struct sockaddr_in *) &rItem.rt_dst, inet_addr("127.0.0.0"), 0);
set_sockaddr((struct sockaddr_in *) &rItem.rt_genmask, inet_addr("255.0.0.0"), 0);
rItem.rt_flags = RTF_UP;// | RTF_HOST;//RTF_GATEWAY;
rItem.rt_dev = "lo0";
set_sockaddr((struct sockaddr_in *) &rItem.rt_gateway, 0, 0);
if ((rt = ioctl(fd,SIOCADDRT, &rItem)) < 0)
{
fprintf(stderr, "Cannot add default route (%d).\n", errno);
}
}
//close(fd);
return (rt < 0 ? FALSE : TRUE);
// return true;
}
