Unix网络编程代码 第20章 广播

最新推荐文章于 2022-07-10 03:45:00 发布
最新推荐文章于 2022-07-10 03:45:00 发布
阅读量671 收藏
点赞数
文章标签： unix 编程 网络 struct signal null
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moxiaopeng/article/details/7199959
版权

第20章 广播

20.4 使用广播的dg_cli函数

//运行前启动daytime服务,运行：./client 192.168.1.255,启动后,随便输入字符
#include	<netinet/in.h>	/* sockaddr_in{} and other Internet defns */
#include	<strings.h>
#include	<stdarg.h>
#include	<stdlib.h>
#include	<stdio.h>
#include	<string.h>
#include	<errno.h>
#include	<arpa/inet.h>
#include	<signal.h>
#include	<unistd.h>
#include	<sys/un.h>
#define	MAXLINE		4096	/* max text line length */
#define	SA	struct sockaddr
typedef void Sigfunc(int);	/* for signal handlers */
void err_doit(int errnoflag, const char *fmt, va_list ap)
{
	int errno_save;
	char buf[MAXLINE];

	errno_save = errno;	/* value caller might want printed */
	vsprintf(buf, fmt, ap);
	if (errnoflag)
		sprintf(buf + strlen(buf), ": %s", strerror(errno_save));
	strcat(buf, "\n");
	fflush(stdout);		/* in case stdout and stderr are the same */
	fputs(buf, stderr);
	fflush(stderr);		/* SunOS 4.1.* doesn't grok NULL argument */
	return;
}

void err_quit(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	err_doit(0, fmt, ap);
	va_end(ap);
	exit(1);
}

void err_sys(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	err_doit(1, fmt, ap);
	va_end(ap);
	exit(1);
}

int Socket(int family, int type, int protocol)
{
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		err_sys("socket error");
	return (n);
}

void Inet_pton(int family, const char *strptr, void *addrptr)
{
	int n;

	if ((n = inet_pton(family, strptr, addrptr)) < 0)
		err_sys("inet_pton error for %s", strptr);	/* errno set */
	else if (n == 0)
		err_quit("inet_pton error for %s", strptr);	/* errno not set */

	/* nothing to return */
}

char *Fgets(char *ptr, int n, FILE * stream)
{
	char *rptr;

	if ((rptr = fgets(ptr, n, stream)) == NULL && ferror(stream))
		err_sys("fgets error");

	return (rptr);
}

ssize_t Recvfrom(int fd, void *ptr, size_t nbytes, int flags,
		 struct sockaddr * sa, socklen_t * salenptr)
{
	ssize_t n;

	if ((n = recvfrom(fd, ptr, nbytes, flags, sa, salenptr)) < 0)
		err_sys("recvfrom error");
	return (n);
}

void Sendto(int fd, const void *ptr, size_t nbytes, int flags,
	    const struct sockaddr *sa, socklen_t salen)
{
	if (sendto(fd, ptr, nbytes, flags, sa, salen) != (ssize_t) nbytes)
		err_sys("sendto error");
}

void Fputs(const char *ptr, FILE * stream)
{
	if (fputs(ptr, stream) == EOF)
		err_sys("fputs error");
}

void recvfrom_alarm(int signo)
{
	return;			/* just interrupt the recvfrom() */
}

void *Malloc(size_t size)
{
	void *ptr;

	if ((ptr = malloc(size)) == NULL)
		err_sys("malloc error");
	return (ptr);
}

void Setsockopt(int fd, int level, int optname, const void *optval,
		socklen_t optlen)
{
	if (setsockopt(fd, level, optname, optval, optlen) < 0)
		err_sys("setsockopt error");
}

Sigfunc *signal(int signo, Sigfunc * func)
{
	struct sigaction act, oact;

	act.sa_handler = func;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	if (signo == SIGALRM) {
#ifdef	SA_INTERRUPT
		act.sa_flags |= SA_INTERRUPT;	/* SunOS 4.x */
#endif
	} else {
#ifdef	SA_RESTART
		act.sa_flags |= SA_RESTART;	/* SVR4, 44BSD */
#endif
	}
	if (sigaction(signo, &act, &oact) < 0)
		return (SIG_ERR);
	return (oact.sa_handler);
}

Sigfunc *Signal(int signo, Sigfunc * func)
{				/* for our signal() function */
	Sigfunc *sigfunc;

	if ((sigfunc = signal(signo, func)) == SIG_ERR)
		err_sys("signal error");
	return (sigfunc);
}

char *sock_ntop_host(const struct sockaddr *sa, socklen_t salen)
{
	static char str[128];	/* Unix domain is largest */

	switch (sa->sa_family) {
	case AF_INET:{
			struct sockaddr_in *sin = (struct sockaddr_in *)sa;

			if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str))
			    == NULL)
				return (NULL);
			return (str);
		}

#ifdef	IPV6
	case AF_INET6:{
			struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;

			if (inet_ntop
			    (AF_INET6, &sin6->sin6_addr, str,
			     sizeof(str)) == NULL)
				return (NULL);
			return (str);
		}
#endif

#ifdef	AF_UNIX
	case AF_UNIX:{
			struct sockaddr_un *unp = (struct sockaddr_un *)sa;

			/* OK to have no pathname bound to the socket: happens on
			   every connect() unless client calls bind() first. */
			if (unp->sun_path[0] == 0)
				strcpy(str, "(no pathname bound)");
			else
				snprintf(str, sizeof(str), "%s", unp->sun_path);
			return (str);
		}
#endif

#ifdef	HAVE_SOCKADDR_DL_STRUCT
	case AF_LINK:{
			struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;

			if (sdl->sdl_nlen > 0)
				snprintf(str, sizeof(str), "%*s",
					 sdl->sdl_nlen, &sdl->sdl_data[0]);
			else
				snprintf(str, sizeof(str), "AF_LINK, index=%d",
					 sdl->sdl_index);
			return (str);
		}
#endif
	default:
		snprintf(str, sizeof(str),
			 "sock_ntop_host: unknown AF_xxx: %d, len %d",
			 sa->sa_family, salen);
		return (str);
	}
	return (NULL);
}

char *Sock_ntop_host(const struct sockaddr *sa, socklen_t salen)
{
	char *ptr;

	if ((ptr = sock_ntop_host(sa, salen)) == NULL)
		err_sys("sock_ntop_host error");	/* inet_ntop() sets errno */
	return (ptr);
}

void dg_cli(FILE * fp, int sockfd, const SA * pservaddr, socklen_t servlen)
{
	int n;
	const int on = 1;
	char sendline[MAXLINE], recvline[MAXLINE + 1];
	socklen_t len;
	struct sockaddr *preply_addr;

	preply_addr = (struct sockaddr *)Malloc(servlen);

	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));

	Signal(SIGALRM, recvfrom_alarm);

	while (Fgets(sendline, MAXLINE, fp) != NULL) {

		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr,
		       servlen);

		alarm(5);
		for (;;) {
			len = servlen;
			n = recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr,
				     &len);
			if (n < 0) {
				if (errno == EINTR)
					break;	/* waited long enough for replies */
				else
					err_sys("recvfrom error");
			} else {
				recvline[n] = 0;	/* null terminate */
				printf("from %s: %s",
				       Sock_ntop_host(preply_addr, len),
				       recvline);
			}
		}
	}
	free(preply_addr);
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

	if (argc != 2)
		err_quit("usage: udpcli <IPaddress>");

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(13);
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

	dg_cli(stdin, sockfd, (SA *) & servaddr, sizeof(servaddr));

	exit(0);
}

22.5 竞争条件
22.5.2 用pselect阻塞和解阻塞信号
//运行前启动daytime服务,运行：./client 192.168.1.255,启动后,随便输入字符
#define _POSIX_SOURCE
#define _POSIX_C_SOURCE  200112L
#include	<sys/select.h>
#include	<netinet/in.h>	/* sockaddr_in{} and other Internet defns */
#include	<strings.h>
#include	<stdarg.h>
#include	<stdlib.h>
#include	<stdio.h>
#include	<string.h>
#include	<errno.h>
#include	<arpa/inet.h>
#include	<signal.h>
#include	<unistd.h>
#include	<sys/un.h>
#define	MAXLINE		4096	/* max text line length */
#define	SA	struct sockaddr
typedef void Sigfunc(int);	/* for signal handlers */
void err_doit(int errnoflag, const char *fmt, va_list ap)
{
	int errno_save;
	char buf[MAXLINE];

	errno_save = errno;	/* value caller might want printed */
	vsprintf(buf, fmt, ap);
	if (errnoflag)
		sprintf(buf + strlen(buf), ": %s", strerror(errno_save));
	strcat(buf, "\n");
	fflush(stdout);		/* in case stdout and stderr are the same */
	fputs(buf, stderr);
	fflush(stderr);		/* SunOS 4.1.* doesn't grok NULL argument */
	return;
}

void err_quit(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	err_doit(0, fmt, ap);
	va_end(ap);
	exit(1);
}

void err_sys(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	err_doit(1, fmt, ap);
	va_end(ap);
	exit(1);
}

int Socket(int family, int type, int protocol)
{
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		err_sys("socket error");
	return (n);
}

void Inet_pton(int family, const char *strptr, void *addrptr)
{
	int n;

	if ((n = inet_pton(family, strptr, addrptr)) < 0)
		err_sys("inet_pton error for %s", strptr);	/* errno set */
	else if (n == 0)
		err_quit("inet_pton error for %s", strptr);	/* errno not set */

	/* nothing to return */
}

char *Fgets(char *ptr, int n, FILE * stream)
{
	char *rptr;

	if ((rptr = fgets(ptr, n, stream)) == NULL && ferror(stream))
		err_sys("fgets error");

	return (rptr);
}

ssize_t Recvfrom(int fd, void *ptr, size_t nbytes, int flags,
		 struct sockaddr * sa, socklen_t * salenptr)
{
	ssize_t n;

	if ((n = recvfrom(fd, ptr, nbytes, flags, sa, salenptr)) < 0)
		err_sys("recvfrom error");
	return (n);
}

void Sendto(int fd, const void *ptr, size_t nbytes, int flags,
	    const struct sockaddr *sa, socklen_t salen)
{
	if (sendto(fd, ptr, nbytes, flags, sa, salen) != (ssize_t) nbytes)
		err_sys("sendto error");
}

void Fputs(const char *ptr, FILE * stream)
{
	if (fputs(ptr, stream) == EOF)
		err_sys("fputs error");
}

void recvfrom_alarm(int signo)
{
	return;			/* just interrupt the recvfrom() */
}

void *Malloc(size_t size)
{
	void *ptr;

	if ((ptr = malloc(size)) == NULL)
		err_sys("malloc error");
	return (ptr);
}

void Setsockopt(int fd, int level, int optname, const void *optval,
		socklen_t optlen)
{
	if (setsockopt(fd, level, optname, optval, optlen) < 0)
		err_sys("setsockopt error");
}

Sigfunc *signal(int signo, Sigfunc * func)
{
	struct sigaction act, oact;

	act.sa_handler = func;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	if (signo == SIGALRM) {
#ifdef	SA_INTERRUPT
		act.sa_flags |= SA_INTERRUPT;	/* SunOS 4.x */
#endif
	} else {
#ifdef	SA_RESTART
		act.sa_flags |= SA_RESTART;	/* SVR4, 44BSD */
#endif
	}
	if (sigaction(signo, &act, &oact) < 0)
		return (SIG_ERR);
	return (oact.sa_handler);
}


Sigfunc *Signal(int signo, Sigfunc * func)
{				/* for our signal() function */
	Sigfunc *sigfunc;

	if ((sigfunc = signal(signo, func)) == SIG_ERR)
		err_sys("signal error");
	return (sigfunc);
}

char *sock_ntop_host(const struct sockaddr *sa, socklen_t salen)
{
	static char str[128];	/* Unix domain is largest */

	switch (sa->sa_family) {
	case AF_INET:{
			struct sockaddr_in *sin = (struct sockaddr_in *)sa;

			if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str))
			    == NULL)
				return (NULL);
			return (str);
		}

#ifdef	IPV6
	case AF_INET6:{
			struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;

			if (inet_ntop
			    (AF_INET6, &sin6->sin6_addr, str,
			     sizeof(str)) == NULL)
				return (NULL);
			return (str);
		}
#endif

#ifdef	AF_UNIX
	case AF_UNIX:{
			struct sockaddr_un *unp = (struct sockaddr_un *)sa;

			/* OK to have no pathname bound to the socket: happens on
			   every connect() unless client calls bind() first. */
			if (unp->sun_path[0] == 0)
				strcpy(str, "(no pathname bound)");
			else
				snprintf(str, sizeof(str), "%s", unp->sun_path);
			return (str);
		}
#endif

#ifdef	HAVE_SOCKADDR_DL_STRUCT
	case AF_LINK:{
			struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;

			if (sdl->sdl_nlen > 0)
				snprintf(str, sizeof(str), "%*s",
					 sdl->sdl_nlen, &sdl->sdl_data[0]);
			else
				snprintf(str, sizeof(str), "AF_LINK, index=%d",
					 sdl->sdl_index);
			return (str);
		}
#endif
	default:
		snprintf(str, sizeof(str),
			 "sock_ntop_host: unknown AF_xxx: %d, len %d",
			 sa->sa_family, salen);
		return (str);
	}
	return (NULL);
}

char *Sock_ntop_host(const struct sockaddr *sa, socklen_t salen)
{
	char *ptr;

	if ((ptr = sock_ntop_host(sa, salen)) == NULL)
		err_sys("sock_ntop_host error");	/* inet_ntop() sets errno */
	return (ptr);
}

void Sigemptyset(sigset_t * set)
{
	if (sigemptyset(set) == -1)
		err_sys("sigemptyset error");
}

void Sigaddset(sigset_t * set, int signo)
{
	if (sigaddset(set, signo) == -1)
		err_sys("sigaddset error");
}
void Sigprocmask(int how, const sigset_t *set, sigset_t *oset)
{
	if (sigprocmask(how, set, oset) == -1)
		err_sys("sigprocmask error");
}

void dg_cli(FILE * fp, int sockfd, const SA * pservaddr, socklen_t servlen)
{
	int n;
	const int on = 1;
	char sendline[MAXLINE], recvline[MAXLINE + 1];
	fd_set rset;
	sigset_t sigset_alrm, sigset_empty;
	socklen_t len;
	struct sockaddr *preply_addr;

	preply_addr = Malloc(servlen);

	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));

	FD_ZERO(&rset);

	Sigemptyset(&sigset_empty);
	Sigemptyset(&sigset_alrm);
	Sigaddset(&sigset_alrm, SIGALRM);

	Signal(SIGALRM, recvfrom_alarm);

	while (Fgets(sendline, MAXLINE, fp) != NULL) {
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr,
		       servlen);

		Sigprocmask(SIG_BLOCK, &sigset_alrm, NULL);
		alarm(5);
		for (;;) {
			FD_SET(sockfd, &rset);
			n = pselect(sockfd + 1, &rset, NULL, NULL, NULL,
				    &sigset_empty);
			if (n < 0) {
				if (errno == EINTR)
					break;
				else
					err_sys("pselect error");
			} else if (n != 1)
				err_sys("pselect error: returned %d", n);

			len = servlen;
			n = Recvfrom(sockfd, recvline, MAXLINE, 0, preply_addr,
				     &len);
			recvline[n] = 0;	/* null terminate */
			printf("from %s: %s",
			       Sock_ntop_host(preply_addr, len), recvline);
		}
	}
	free(preply_addr);
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

	if (argc != 2)
		err_quit("usage: udpcli <IPaddress>");

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(13);
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

	dg_cli(stdin, sockfd, (SA *) & servaddr, sizeof(servaddr));

	exit(0);
}



22.5.4 使用信号处理函数到主控函数的IPC


//运行前启动daytime服务,运行：./client 192.168.1.255,启动后,随便输入字符
#define _POSIX_SOURCE
#include	<sys/select.h>
#include	<netinet/in.h>	/* sockaddr_in{} and other Internet defns */
#include	<strings.h>
#include	<stdarg.h>
#include	<stdlib.h>
#include	<stdio.h>
#include	<string.h>
#include	<errno.h>
#include	<arpa/inet.h>
#include	<signal.h>
#include	<unistd.h>
#include	<sys/un.h>
#define	max(a,b)	((a) > (b) ? (a) : (b))
#define	MAXLINE		4096	/* max text line length */
#define	SA	struct sockaddr
typedef void Sigfunc(int);	/* for signal handlers */
void err_doit(int errnoflag, const char *fmt, va_list ap)
{
	int errno_save;
	char buf[MAXLINE];

	errno_save = errno;	/* value caller might want printed */
	vsprintf(buf, fmt, ap);
	if (errnoflag)
		sprintf(buf + strlen(buf), ": %s", strerror(errno_save));
	strcat(buf, "\n");
	fflush(stdout);		/* in case stdout and stderr are the same */
	fputs(buf, stderr);
	fflush(stderr);		/* SunOS 4.1.* doesn't grok NULL argument */
	return;
}

void err_quit(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	err_doit(0, fmt, ap);
	va_end(ap);
	exit(1);
}

void err_sys(const char *fmt, ...)
{
	va_list ap;

	va_start(ap, fmt);
	err_doit(1, fmt, ap);
	va_end(ap);
	exit(1);
}

int Socket(int family, int type, int protocol)
{
	int n;

	if ((n = socket(family, type, protocol)) < 0)
		err_sys("socket error");
	return (n);
}

void Inet_pton(int family, const char *strptr, void *addrptr)
{
	int n;

	if ((n = inet_pton(family, strptr, addrptr)) < 0)
		err_sys("inet_pton error for %s", strptr);	/* errno set */
	else if (n == 0)
		err_quit("inet_pton error for %s", strptr);	/* errno not set */

	/* nothing to return */
}

char *Fgets(char *ptr, int n, FILE * stream)
{
	char *rptr;

	if ((rptr = fgets(ptr, n, stream)) == NULL && ferror(stream))
		err_sys("fgets error");

	return (rptr);
}

ssize_t Recvfrom(int fd, void *ptr, size_t nbytes, int flags,
		 struct sockaddr * sa, socklen_t * salenptr)
{
	ssize_t n;

	if ((n = recvfrom(fd, ptr, nbytes, flags, sa, salenptr)) < 0)
		err_sys("recvfrom error");
	return (n);
}

void Sendto(int fd, const void *ptr, size_t nbytes, int flags,
	    const struct sockaddr *sa, socklen_t salen)
{
	if (sendto(fd, ptr, nbytes, flags, sa, salen) != (ssize_t) nbytes)
		err_sys("sendto error");
}

void Fputs(const char *ptr, FILE * stream)
{
	if (fputs(ptr, stream) == EOF)
		err_sys("fputs error");
}

void *Malloc(size_t size)
{
	void *ptr;

	if ((ptr = malloc(size)) == NULL)
		err_sys("malloc error");
	return (ptr);
}

void Setsockopt(int fd, int level, int optname, const void *optval,
		socklen_t optlen)
{
	if (setsockopt(fd, level, optname, optval, optlen) < 0)
		err_sys("setsockopt error");
}

Sigfunc *signal(int signo, Sigfunc * func)
{
	struct sigaction act, oact;

	act.sa_handler = func;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	if (signo == SIGALRM) {
#ifdef	SA_INTERRUPT
		act.sa_flags |= SA_INTERRUPT;	/* SunOS 4.x */
#endif
	} else {
#ifdef	SA_RESTART
		act.sa_flags |= SA_RESTART;	/* SVR4, 44BSD */
#endif
	}
	if (sigaction(signo, &act, &oact) < 0)
		return (SIG_ERR);
	return (oact.sa_handler);
}

Sigfunc *Signal(int signo, Sigfunc * func)
{				/* for our signal() function */
	Sigfunc *sigfunc;

	if ((sigfunc = signal(signo, func)) == SIG_ERR)
		err_sys("signal error");
	return (sigfunc);
}

char *sock_ntop_host(const struct sockaddr *sa, socklen_t salen)
{
	static char str[128];	/* Unix domain is largest */

	switch (sa->sa_family) {
	case AF_INET:{
			struct sockaddr_in *sin = (struct sockaddr_in *)sa;

			if (inet_ntop(AF_INET, &sin->sin_addr, str, sizeof(str))
			    == NULL)
				return (NULL);
			return (str);
		}

#ifdef	IPV6
	case AF_INET6:{
			struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)sa;

			if (inet_ntop
			    (AF_INET6, &sin6->sin6_addr, str,
			     sizeof(str)) == NULL)
				return (NULL);
			return (str);
		}
#endif

#ifdef	AF_UNIX
	case AF_UNIX:{
			struct sockaddr_un *unp = (struct sockaddr_un *)sa;

			/* OK to have no pathname bound to the socket: happens on
			   every connect() unless client calls bind() first. */
			if (unp->sun_path[0] == 0)
				strcpy(str, "(no pathname bound)");
			else
				snprintf(str, sizeof(str), "%s", unp->sun_path);
			return (str);
		}
#endif

#ifdef	HAVE_SOCKADDR_DL_STRUCT
	case AF_LINK:{
			struct sockaddr_dl *sdl = (struct sockaddr_dl *)sa;

			if (sdl->sdl_nlen > 0)
				snprintf(str, sizeof(str), "%*s",
					 sdl->sdl_nlen, &sdl->sdl_data[0]);
			else
				snprintf(str, sizeof(str), "AF_LINK, index=%d",
					 sdl->sdl_index);
			return (str);
		}
#endif
	default:
		snprintf(str, sizeof(str),
			 "sock_ntop_host: unknown AF_xxx: %d, len %d",
			 sa->sa_family, salen);
		return (str);
	}
	return (NULL);
}

char *Sock_ntop_host(const struct sockaddr *sa, socklen_t salen)
{
	char *ptr;

	if ((ptr = sock_ntop_host(sa, salen)) == NULL)
		err_sys("sock_ntop_host error");	/* inet_ntop() sets errno */
	return (ptr);
}

void Pipe(int *fds)
{
	if (pipe(fds) < 0)
		err_sys("pipe error");
}

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
	ssize_t n;

	if ((n = read(fd, ptr, nbytes)) == -1)
		err_sys("read error");
	return (n);
}

void Write(int fd, void *ptr, int nbytes)
{
	if (write(fd, ptr, nbytes) != nbytes)
		err_sys("write error");
}

static int pipefd[2];

static void recvfrom_alarm(int signo)
{
	Write(pipefd[1], "", 1);	/* write one null byte to pipe */
	return;
}

void dg_cli(FILE * fp, int sockfd, const SA * pservaddr, socklen_t servlen)
{
	int n, maxfdp1;
	const int on = 1;
	char sendline[MAXLINE], recvline[MAXLINE + 1];
	fd_set rset;
	socklen_t len;
	struct sockaddr *preply_addr;

	preply_addr = Malloc(servlen);

	Setsockopt(sockfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on));

	Pipe(pipefd);
	maxfdp1 = max(sockfd, pipefd[0]) + 1;

	FD_ZERO(&rset);

	Signal(SIGALRM, recvfrom_alarm);

	while (Fgets(sendline, MAXLINE, fp) != NULL) {
		Sendto(sockfd, sendline, strlen(sendline), 0, pservaddr,
		       servlen);

		alarm(5);
		for (;;) {
			FD_SET(sockfd, &rset);
			FD_SET(pipefd[0], &rset);
			if ((n = select(maxfdp1, &rset, NULL, NULL, NULL)) < 0) {
				if (errno == EINTR)
					continue;
				else
					err_sys("select error");
			}

			if (FD_ISSET(sockfd, &rset)) {
				len = servlen;
				n = Recvfrom(sockfd, recvline, MAXLINE, 0,
					     preply_addr, &len);
				recvline[n] = 0;	/* null terminate */
				printf("from %s: %s",
				       Sock_ntop_host(preply_addr, len),
				       recvline);
			}

			if (FD_ISSET(pipefd[0], &rset)) {
				Read(pipefd[0], &n, 1);	/* timer expired */
				break;
			}
		}
	}
	free(preply_addr);
}

int main(int argc, char **argv)
{
	int sockfd;
	struct sockaddr_in servaddr;

	if (argc != 2)
		err_quit("usage: udpcli <IPaddress>");

	bzero(&servaddr, sizeof(servaddr));
	servaddr.sin_family = AF_INET;
	servaddr.sin_port = htons(13);
	Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);

	sockfd = Socket(AF_INET, SOCK_DGRAM, 0);

	dg_cli(stdin, sockfd, (SA *) & servaddr, sizeof(servaddr));

	exit(0);
}













                

        

        

    

  


    

      

        

            

              
                
                  MoXiaopeng
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
UNIX网络编程卷一：第二十章 广播

				
			

			

				

					Huntinux
				

				

					08-17
					
					546
					
				

			

		

		

			
				
TCP只支持单播寻址
UDP和原始IP还支持其它寻址类型。

IPv6中增加了任播方式。


广播（broadcastign）：
用途1： 在本地子网定位一个服务器主机，这种操作成为资源发现。
用途2： 在多个客户主机和单个服务器主机通信的局域网环境种尽量减少分组流通， 如：
     a） ARP ： ARP在本地子网上广播一个请求：“IP地址为a.b.c.d的系统亮明身份，告

			
		

	



                

            
              



	

		

			

				
					
Unix下UDP广播群聊例程

				
			

			

				

					
				

				

					09-12
					
					112
					
				

			

		

		

			
				
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>
#i...

			
		

	



              


  
              

                


	

		

			

				
					
Linux UDP实现广播

				
			

			

				

					一颗牙疼
				

				

					12-11
					
					2690
					
				

			

		

		

			
				
有些时候今日事今日毕未必是好事，今天解决不了的bug留到明天或许就解决了
特点：
较TCP来讲UDP无需建立连接可以直接发送消息，UDP是对网络环境完全不弥补的协议，所以使用DUP就要允许有一定的丢包率，UDP广播是面向局域网内所有的设备的。
对比TCP连接时服务端的IP地址的重要性来讲，UDP广播中本机的IP显得并不重要了。
广播地址：
我们知道在IPV4地址中是采用点分十进制的方法来表示IP地...

			
		

	





	

		

			

				
					
[转]UDP（udp通信、广播、组播），本地套接字

				
			

			

				

					zhaodeming000的博客
				

				

					07-16
					
					377
					
				

			

		

		

			
				
转发：c/c++：UDP（udp通信、广播、组播），本地套接字

            
                            
                                            目录
1. udp
1.1 udp通信流程
1.2 操作函数
send、sendto
recv、recvfrom
2. 广播
2.1 广播通信流程
2.2 设置广播属性函数：setsockopt
2.3 广播代码
3 组播
3.1 组播地址
3.2&nb

			
		

	



		

			
		



	

		

			

				
					
Linux下UDP广播的deamo

				
			

			

				

					Mr.Sugarcane
				

				

					03-09
					
					480
					
				

			

		

		

			
				
deamo1：【下位机执行发送广播文件，上位机可抓包到UDP通讯数据】#include&lt;stdio.h&gt;
#include&lt;stdlib.h&gt;
#include&lt;string.h&gt;
#include&lt;sys/types.h&gt;
#include&lt;sys/socket.h&gt;
#include&lt;sys/wait.h&gt;
#includ...

			
		

	





	

		

			

				
					
UNIX网络编程 第2卷 进程间通信.pdf（带书签）

				
			

			

				

					08-09
				

			

		

		

			
				
第20章到第25章则深入讨论了广播、多播、带外数据和信号驱动I/O等网络通信的高级特性。第26章对线程编程进行了讲解，展示了如何利用多线程技术提升网络服务的性能。第27章讨论了IP选项的应用，而第28章和第29章则...

			
		

	





	

		

			

				
					
UNIX网络编程 卷2 进程间通信 带完整书签，完整目录

				
			

			

				

					09-20
				

			

		

		

			
				
第二部分 消息传递 31  第4章 管道和FIFO 32  4.1 概述 32  4.2 一个简单的客户－服务器例子 32  4.3 管道 32  4.4 全双工管道 37  4.5 popen和pclose函数 39  4.6 FIFO 40  4.7 管道和FIFO的额外属性 44  4.8 单个...

			
		

	





	

		

			

				
					
网络编程--UNIX网络编程 卷1

				
			

			

				

					Hanrui的博客
				

				

					07-07
					
					1227
					
				

			

		

		

			
				
TCP与UDP协议的优缺点及适用场景

TCP: 面向连接的可靠数据包传递 ----- 完全弥补

优点：稳定 1、数据稳定 --- 丢包回传（回执机制）2、速率稳定 3、流量稳定 “滑动窗口”

缺点：效率低、速度慢

适用场景：大文件、重要文件传输

UDP：无连接的不可靠报文传递 ----- 完全不弥补

缺点：不稳定 数据、速率、流量

优点：效率高、速度快

适用场景：对实时性要求较高，视频会议、视频电话、广播

如何提高UDP传输的可靠性？

我们使用UDP进行网络编程所遇到的问题是它缺乏可靠性

			
		

	





	

		

			

				
					
UNIX网络编程 卷2：进程间通信

				
			

			

				

					06-16
				

			

		

		

			
				
　第二部分 消息传递 　第4章 管道和FIFO 32 　4.1 概述 32 　4.2 一个简单的客户-服务器例子 32 　4.3 管道 32 　4.4 全双工管道 37 　4.5 popen和pclose函数 39 　4.6 FIFO 40 　4.7 管道和FIFO的额外属性 44 　...

			
		

	





	

		

			

				
					
UNIX网络编程 卷1：套接字联网API

				
			

			

				

					06-16
				

			

		

		

			
				
第20章　广播  第21章　多播  第22章　高级UDP套接字编程  第23章　高级SCTP套接字编程  第24章　带外数据  第25章　信号驱动式I/O  第26章　线程  第27章　IP选项  第28章　原始套接字  第29章　数据链路访问  第30...

			
		

	





	

		

			

				
					
【UNIX网络编程】广播与多播

				
			

			

				

					yw8355507的专栏
				

				

					06-29
					
					595
					
				

			

		

		

			
				
前言
继续补上我的博客，这几天专注把【UNIX网络编程】的内容总结。
1.单播与广播的比较
单播 过程：




中间主机的以太网接口看到该帧，并将它的目的以太网与自己的以太网地址进行比较。由于二者不相等，接口便忽略该帧。因此，单播帧不会对这台主机造成任何额外开销，因为忽略它们的是接口而不是主机。

右边主机的以太网接口也看到该帧。并将它的目的以太网与自己的以太网地址进行比较。

			
		

	





	

		

			

				
					
域服务器广播消息,广播,组播和UNIX域套接字

				
			

			

				

					weixin_35915828的博客
				

				

					08-13
					
					559
					
				

			

		

		

			
				
1.广播1.特点一对多仅能使用UDP2.概念发送方只有一个接收方则称单播如果同时发给局域网中的所有主机,成为广播只有用户数据包(使用UDP协议)套接字才能广播广播地址1.以192.168.1.0(255.255.255.0)网段为例,最大的主机地址192.168.1.255代表该网段的广播地址2.发送到该地址的数据包将被所有主机接收3.255.255.255.255在所有网段中都代表广播地址3.广...

			
		

	





	

		

			

				
					
Linux 多进程通信开发(七): unix domain socket 之 UDP 通信

				
			

			

				

					frank 的专栏
				

				

					04-17
					
					8167
					
				

			

		

		

			
				
这会是一系列文章，讲解的内容也很简单，文章的目的是让自己的知识固话和文档化，以备自己不时的复习，同时也希望能够给予初学者一些帮助。

前面的文章一系列文章有介绍了 linux 下常见的 IPC 机制，如管道、消息队列、信号量、共享内存。
之前有讲到共享内存是最高效的 IPC 方式，但是在 linux 环境下，应用最广泛的可能是 Socket。
什么是 Unix Domain Socket ?
S...

			
		

	





	

		

			

				
					
alin的学习之路（Linux网络编程：七）（UDP广播、UDP组播、本地套接字）

				
			

			

				

					alin的博客
				

				

					08-07
					
					429
					
				

			

		

		

			
				
alin的学习之路（Linux网络编程：七）（UDP广播、UDP组播、本地套接字）
1. UDP 广播
通过UDP 广播可以将数据发送给同一网段下的所有指定端口号的进程。但是不能够在Internet上传输数据，只能在局域网中。
注意：只要是存在在与服务器同一网段内的主机，都会收到广播的数据，无论是否需要。

广播地址：192.168 .xxx. 255
服务器的地址（IP+port）不那么重要了。 可以依赖隐式绑定。
客户端的port，必须要固定。不能再依赖隐式绑定。
只适用于 “局域网” 通信。

1. 

			
		

	





	

		

			

				
					
Linux高并发服务器开发—UDP、广播、组播、本地socket

				
			

			

				

					梅山
				

				

					07-10
					
					628
					
				

			

		

		

			
				
udp服务端

udp客户端

UDP通信的现象：
向子网中多台计算机发送消息，并且子网中所有的计算机都可以接收到发送方发送的消息，每个广
播消息都包含一个特殊的IP地址，这个IP中子网内主机标志部分的二进制全部为1。
a.只能在局域网中使用。
b.客户端需要绑定服务器广播使用的端口，才可以接收到广播消息。

广播服务端

广播客户端

组播(多播)——了解
单播地址标识单个 IP 接口，广播地址标识某个子网的所有 IP 接口，多播地址标识一组 IP 接口。单播和广播是寻址方案的两个极端（要么单个要么全部）

			
		

	





	

		

			

				
					
Linux系统下UDP发送和接收广播消息小例子

					
热门推荐

				
			

			

				

					迎风的舵手
				

				

					01-07
					
					4万+
					
				

			

		

		

			
				
// 发送端
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 


using namespace std;

int main()
{
	setvbuf(stdout, NULL, _IONBF, 0); 
	fflush(stdout); 

	int sock =

			
		

	





	

		

			

				
					
linux udp 单播 组播 广播实现

				
			

			

				

					
				

				

					02-04
					
					1172
					
				

			

		

		

			
				
1、组播和广播需要在局域网内才能实现，另外得查看linux系统是否支持多播和广播：ifconfig
     UP
 BROADCAST MULTICAST MTU:1500  跃点数:1
     说明该网卡支持
2、发送多播包的主机需要设置网关，否则运行sendto()会出现"network is unreachable"，网卡可以随便设置，但是一定要设。还要添加路由240.0.0.0

			
		

	





	

		

			

				
					
linux 组播编程

				
			

			

				

					
				

				

					06-17
					
					3692
					
				

			

		

		

			
				
组播客户端代码如下：<br /><br /><br />
#include <sys/types.h><br />
#include <sys/socket.h><br />
#include <arpa/inet.h><br />
#include <stdio.h><br />
#include <stdlib.h><br />
#include <string.h><br /><br />
#define BUFLEN 255<br />
int main(int argc, char

			
		

	





	

		

			

				
					
unix网络编程代码

					
最新发布

				
			

			

				

					10-07
				

			

		

		

			
				
下面是一个简单的Unix网络编程的代码示例：  #include #include #include #include #include #include #include #include  int main() {  int sockfd;  struct sockaddr_in servaddr, cliaddr;  char buffer[1024]; ...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值