int
main(int argc, char **argv)
{
int sockfd;
const int on = 1;
socklen_t salen;
struct sockaddr *sa;
if (argc == 1) {
sockfd = udp_client(SAP_NAME, SAP_PORT, &sa, &salen);
} else if (argc == 4) {
sockfd = udp_client(argv[1], argv[2], &sa, &salen);
} else {
fprintf(stderr, "usage: mysdr <mcast-addr> <port#> <interface-name>\n");
exit(1);
}
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
perror("setsockopt error");
exit(1);
}
if (bind(sockfd, sa, salen) < 0) {
perror("bind error");
exit(1);
}
if (mcast_join(sockfd, sa, salen, (argc == 4) ? argv[3] : NULL, 0) < 0) {
perror("mcast_join error");
exit(1);
}
loop(sockfd, salen); /* receive and print */
exit(0);
}
void
Mcast_join(int sockfd, const SA *sa, socklen_t salen,
const char *ifname, u_int ifindex)
{
if (mcast_join(sockfd, sa, salen, ifname, ifindex) < 0)
err_sys("mcast_join error");
}
int Mcast_join(int sockfd, const char *mcast_addr,
const char *ifname, u_int ifindex)
{
#ifndef IPV6
/* IPv4 */
struct sockaddr_in sa;
sa.sin_family = AF_INET;
inet_pton(AF_INET, mcast_addr, &sa.sin_addr);
#else
struct sockaddr_in6 sa;
sa.sin6_family = AF_INET6;
inet_pton(AF_INET6, mcast_addr, &sa.sin6_addr);
#endif
return (mcast_join(sockfd, (struct sockaddr *) &sa, sizeof(sa),
ifname, ifindex));
}
int main(int argc, char *argv[])
{
int sockfd;
int n;
const int on = 1;
struct sockaddr_in sarecv;
struct sockaddr_in safrom;
socklen_t salen;
char line[MAXLINE];
char buf[INET_ADDRSTRLEN];
if (argc != 4)
err_quit("Usage: %s <interface> <multicast addr> <#port>", basename(argv[0]));
if ((sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
err_sys("socket error");
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
err_sys("setsockopt error");
bzero(&sarecv, sizeof(struct sockaddr_in));
sarecv.sin_family = AF_INET;
sarecv.sin_port = htons(atoi(argv[3]));
if (inet_pton(AF_INET, argv[2], &sarecv.sin_addr) != 1) {
errno = EINVAL;
err_sys("inet_pton error");
}
if (bind(sockfd, (struct sockaddr *)&sarecv, sizeof(struct sockaddr_in)) < 0)
err_sys("bind error");
if (mcast_join(sockfd, argv[1], argv[2]) < 0)
err_sys("mcast_join error");
for (;;) {
salen = sizeof(struct sockaddr_in);
n = recvfrom(sockfd, line, MAXLINE-1, 0, (struct sockaddr *)&safrom, &salen);
if (n <= 0) break;
line[n] = 0;
printf("from %s: %s", inet_ntop(AF_INET, &safrom.sin_addr, buf, sizeof(buf)), line);
}
return 0;
}
int main(int argc,char *argv[])
{
int sendfd,recvfd;
const int on=1;
socklen_t salen;
struct sockaddr *sasend,*sarecv;
int retval;
fprintf(stderr,"\nMULTICAST DATA MOVER : \n%s %s %s %s %s %s\n",
argv[0],argv[1],argv[2],argv[3],argv[4],argv[5]);
glb.sourcefd = atoi(argv[3]);
glb.filesize = atoi(argv[4]);
strcpy(glb.IBP_cap,argv[5]);
strcpy(group,argv[1]);
sendfd=udp_client(argv[1],argv[2],(void **)&sasend,&salen);
setsockopt(sendfd,SOL_SOCKET,SO_REUSEADDR,&on,sizeof(on));
sarecv=malloc(salen);
memcpy(sarecv,sasend,salen);
bind(sendfd,sasend,salen);
mcast_join(sendfd,sasend,salen,NULL,0);
printf("-->in here 1 \n");
retval=ReceiveData(sendfd,salen);
if(retval < 0)
{
printf("abrubtly ended due to error \n");
mcast_leave(sendfd,sasend,salen);
exit(3);
}
mcast_leave(sendfd,sasend,salen);
printf("recieved all data \n");
exit(0);
}
int
main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in servaddr, grpaddr, cliaddr;
sockfd = Socket(AF_INET, SOCK_DGRAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(sockfd, (SA *) &servaddr, sizeof(servaddr));
bzero(&grpaddr, sizeof(servaddr));
grpaddr.sin_family = AF_INET;
grpaddr.sin_addr.s_addr = inet_addr("224.0.0.1");
mcast_join(sockfd, &grpaddr, sizeof(grpaddr), NULL, 0);
dg_echo(sockfd, (SA *) &cliaddr, sizeof(cliaddr));
}
int main(int argc, char **argv)
{
int sendfd, recvfd;
const int on = 1;
socklen_t salen;
struct sockaddr *sasend, *sarecv;
int result;
int onoff = 0;
if (argc != 3) {
printf("usage: ./multicasting <IP-multicast-address> <port#> <>");
exit(1);
}
sendfd = udp_sender(argv[1], argv[2], &sasend, &salen);
recvfd = socket(sasend->sa_family, SOCK_DGRAM, 0);
assert(recvfd > 2);
// Now IP from iface
// int fd;
// struct ifreq ifr;
// fd = socket(AF_INET, SOCK_DGRAM, 0);
// /* I want to get an IPv4 IP address */
// ifr.ifr_addr.sa_family = AF_INET;
// /* I want IP address attached to "eth0" */
// strncpy(ifr.ifr_name, "enp0s25", IFNAMSIZ-1);
// ioctl(fd, SIOCGIFADDR, &ifr);
// close(fd);
/* display result */
//printf("%s\n", inet_ntoa( ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr) );
// I don't want default iface but wlo1
result = setsockopt(recvfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
assert(result >= 0);
sarecv = malloc(salen);
assert(sarecv != NULL);
memcpy(sarecv, sasend, salen);
result = bind(recvfd, sarecv, salen);
assert(result >= 0);
char *src_host = sock_ntop(sarecv);
printf("src_host = %s\n", src_host);
char *dst_host = sock_ntop(sasend);
printf("dst_host = %s\n", dst_host);
result = mcast_join(recvfd, sasend, salen);
assert(result >= 0);
result = setsockopt(sendfd, IPPROTO_IP, IP_MULTICAST_LOOP,
&onoff, sizeof(onoff));
assert(result >= 0);
// struct in_addr interface_addr;// = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr;
// interface_addr.s_addr = htonl(IP_SRC_ADDR_ENP);
// result = setsockopt(recvfd, IPPROTO_IP, IP_MULTICAST_IF, &interface_addr, sizeof(interface_addr));
// assert(result >= 0);
if (fork() == 0)
recv_all(recvfd, salen);
send_all(sendfd, sasend, salen);
return 0;
}
int
main(int argc, char **argv)
{
int sockfd, fd = 5; //random fd > stderr
const int on = 1, op = RCVBUF;
struct sockaddr *sa;
socklen_t salen;
struct sigaction sig;
struct tm tm;
char fname[64] = {0};
char *buf;
time_t t;
ssize_t n, i, cnt;
pthread_t pid;
if (argc < 4) {
fputs("\nUsage: cute <MCast GRP> <UDP port> <dump location> [if name]\n", stderr);
exit(1);
}
//file is created and grown in current working folder
printf("\nUse SIGHUP to start over or SIGTERM to slice the record to %s\n", argv[3]);
sockfd = udp_client(argv[1], argv[2], &sa, &salen); //creates socket and fills sockaddr
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0) {
perror("setsockopt reuseaddr");
exit(1);
}
if (setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, &op, sizeof(op)) < 0) {
perror("setsockopt rcvbuf");
exit(1);
}
if (bind(sockfd, sa, salen) < 0) {
perror("bind");
exit(1);
}
bzero(&sig, sizeof(sig));
sig.sa_handler = slicenow;
if (sigaction(SIGTERM, &sig, NULL) < 0) {
perror("sigaction term");
exit(1);
}
if (sigaction(SIGHUP, &sig, NULL) < 0) {
perror("sigaction hup");
exit(1);
}
if (sigaction(SIGINT, &sig, NULL) < 0) {
perror("sigaction int");
exit(1);
}
if (mcast_join(sockfd, sa, salen, (argc == 5) ? argv[4] : NULL, 0) < 0) {
perror("mcast_join");
//exit(1);
}
if ( (buf = malloc(RCVBUF / 2)) == NULL) { // buffer for recv()
fputs("malloc error", stderr);
exit(1);
}
printf("Niceness set: %d\n\n", nice(LIFT));
for (; ;) {
if (sflag != 0) {
if (sflag == SIGINT) {
//unlink(fname);
puts("");
exit(0);
}
time(&t);
if (gmtime_r(&t, &tm) == NULL) {
fputs("gmtime_r error", stderr);
exit(1);
}
strcpy(filename, fname);
snprintf(fname, sizeof(fname), "%04d%02d%02d%02d%02d%02d.ts",\
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour,\
tm.tm_min, tm.tm_sec);
puts(fname);
close(fd); //first time error is ignored
if ( (fd = creat(fname, 0644)) < 0) {
perror("create");
exit(1);
}
if (sflag == SIGHUP) unlink(filename);
else if (sflag == SIGTERM)
if ( (errno = pthread_create(&pid, NULL, file_move, argv[3])) != 0)
perror("pthread_create");
sflag = 0;
}
//MSG_WAITALL looks irrelevant for SOCK_DGRAM
if ( (n = recv(sockfd, buf, RCVBUF / 2, MSG_WAITALL)) < 0) {
if (errno == EINTR) continue;
else {
perror("recv()");
exit(1);
}
}
if (n > 0) {
i = 0;
while (i < n) if ( (cnt = write(fd, buf + i, n - i)) < 0) {
if (errno == EINTR) continue;
else {
perror("write()");
exit(1);
}
} else i += cnt;
} else fputs("paradox: recv() returned 0", stderr);
}
return 0;
}
Sock * Sock_connect(char *host, char *port, Sock *binded, sock_type socktype, sock_flags ssl_flag)
{
Sock *s;
char remote_host[128]; /*Unix Domain is largest*/
char local_host[128]; /*Unix Domain is largest*/
int sockfd = -1;
struct sockaddr *sa_p = NULL;
socklen_t sa_len = 0;
int32_t local_port;
int32_t remote_port;
#if HAVE_SSL
SSL *ssl_con;
#endif
if(binded) {
sockfd = binded->fd;
}
if (sock_connect(host, port, &sockfd, socktype)) {
net_log(NET_LOG_ERR, "Sock_connect() failure.\n");
return NULL;
}
#if HAVE_SSL
if(ssl_flag & IS_SSL) {
if (sock_SSL_connect(&ssl_con))
net_log (NET_LOG_ERR, "Sock_connect() failure in SSL init.\n");
sock_close(sockfd);
return NULL;
}
else
#endif
if (binded) {
s = binded;
free(s->local_host);
s->local_host = NULL;
free(s->remote_host);
s->remote_host = NULL;
} else if (!(s = calloc(1, sizeof(Sock)))) {
net_log(NET_LOG_FATAL, "Unable to allocate a Sock struct in Sock_connect().\n");
#if HAVE_SSL
if(ssl_flag & IS_SSL)
sock_SSL_close(ssl_con);
#endif
sock_close (sockfd);
return NULL;
}
s->fd = sockfd;
s->socktype = socktype;
#if HAVE_SSL
if(ssl_flag & IS_SSL)
s->ssl = ssl_con;
#endif
s->flags = ssl_flag;
sa_p = (struct sockaddr *) &(s->local_stg);
sa_len = sizeof(struct sockaddr_storage);
if(getsockname(s->fd, sa_p, &sa_len))
{
net_log(NET_LOG_ERR, "Unable to get remote port in Sock_connect().\n");
Sock_close(s);
return NULL;
}
if(!sock_ntop_host(sa_p, local_host, sizeof(local_host)))
memset(local_host, 0, sizeof(local_host));
if (!(s->local_host = strdup(local_host))) {
net_log(NET_LOG_FATAL, "Unable to allocate local host in Sock_connect().\n");
Sock_close(s);
return NULL;
}
local_port = sock_get_port(sa_p);
if(local_port < 0) {
net_log(NET_LOG_ERR, "Unable to get local port in Sock_connect().\n");
Sock_close(s);
return NULL;
} else
s->local_port = ntohs(local_port);
sa_p = (struct sockaddr *) &(s->remote_stg);
sa_len = sizeof(struct sockaddr_storage);
if(getpeername(s->fd, sa_p, &sa_len))
{
net_log(NET_LOG_ERR, "Unable to get remote address in Sock_connect().\n");
Sock_close(s);
return NULL;
}
if(!sock_ntop_host(sa_p, remote_host, sizeof(remote_host)))
memset(remote_host, 0, sizeof(remote_host));
if (!(s->remote_host = strdup(remote_host))) {
net_log(NET_LOG_FATAL, "Unable to allocate remote host in Sock_connect().\n");
Sock_close(s);
return NULL;
}
remote_port = sock_get_port(sa_p);
if(remote_port < 0) {
net_log(NET_LOG_ERR, "Unable to get remote port in Sock_connect().\n");
Sock_close(s);
return NULL;
} else
s->remote_port = ntohs(remote_port);
net_log(NET_LOG_DEBUG, "Socket connected between local=\"%s\":%u and "
"remote=\"%s\":%u.\n", s->local_host, s->local_port, s->remote_host,
s->remote_port);
if(is_multicast_address(sa_p, s->remote_stg.ss_family)) {
//fprintf(stderr,"IS MULTICAST\n");
if(mcast_join(s->fd, sa_p, NULL, 0, &(s->addr))!=0) {
Sock_close(s);
return NULL;
}
s->flags |= IS_MULTICAST;
}
return s;
}
Sock * Sock_bind(char const *host, char const *port, Sock *sock,
sock_type socktype, void * octx)
{
Sock *s = NULL;
int sockfd = -1;
struct sockaddr *sa_p;
socklen_t sa_len;
char local_host[128];
int local_port;
#if ENABLE_SSL
if ((octx)) {
if(socktype != TCP) {
net_log(NET_LOG_ERR, "SSL can't work on this protocol.\n");
return NULL;
}
}
#endif
if(sock) {
sockfd = sock->fd;
}
if (sock_bind(host, port, &sockfd, socktype)) {
net_log(NET_LOG_ERR, "Error in low level sock_bind().\n");
return NULL;
}
if (!(s = calloc(1, sizeof(Sock)))) {
net_log(NET_LOG_FATAL,
"Unable to allocate a Sock struct in Sock_bind().\n");
sock_close(sockfd);
return NULL;
}
s->fd = sockfd;
s->socktype = socktype;
s->flags = 0;
sa_p = (struct sockaddr *)&(s->local_stg);
sa_len = sizeof(struct sockaddr_storage);
if(getsockname(s->fd, sa_p, &sa_len) < 0) {
Sock_close(s);
return NULL;
}
if(!sock_ntop_host(sa_p, local_host, sizeof(local_host)))
memset(local_host, 0, sizeof(local_host));
if (!(s->local_host = strdup(local_host))) {
net_log(NET_LOG_FATAL,
"Unable to allocate local host in Sock_bind().\n");
Sock_close(s);
return NULL;
}
local_port = sock_get_port(sa_p);
if(local_port < 0) {
net_log(NET_LOG_ERR, "Unable to get local port in Sock_bind().\n");
Sock_close(s);
return NULL;
} else
s->local_port = ntohs(local_port);
net_log(NET_LOG_DEBUG,
"Socket bound with addr=\"%s\" and port=\"%u\".\n",
s->local_host, s->local_port);
if(is_multicast_address(sa_p, s->local_stg.ss_family)) {
if(mcast_join(s->fd, sa_p)) {
Sock_close(s);
return NULL;
}
s->flags |= IS_MULTICAST;
}
return s;
}
