Linux/unix下的IPC-UNIX Domain Socket

/* wrap.h */
#ifndef __WRAP_H__
#define __WRAP_H__
void perr_exit(const char* s);
int Accept(int fd, struct sockaddr* sa, socklen_t* salenptr);
void Bind(int fd, const struct sockaddr* sa, socklen_t salen);
void Connect(int fd, const struct sockaddr* sa, socklen_t salen);
void Listen(int fd, int backlog);
int Socket(int family, int type, int protocol);
ssize_t Read(int fd, void* ptr, size_t nbytes);
ssize_t Write(int fd, const void* ptr, size_t nbytes);
void Close(int fd);
ssize_t Readn(int fd, void* vptr, size_t n);
ssize_t Writen(int fd, const void* vptr, size_t n);
static ssize_t my_read(int fd, char* ptr);
ssize_t Readline(int fd, void* vptr, size_t maxlen);
#endif
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <stdio.h>
#include <unistd.h>
#include “wrap.h”
void perr_exit(const char* s)
{
perror(s);
exit(1);
}
int Accept(int fd, struct sockaddr* sa, socklen_t* salenptr)
{
int n;
again:
if ( (n = accept(fd, sa, salenptr)) < 0 )
{
if ((errno == ECONNABORTED)  (errno == EINTR))
{
goto again;
}
else
{
perr_exit(“accept error”);
}
}
return n;
}
void Bind(int fd, const struct sockaddr* sa, socklen_t salen)
{
if ( bind(fd, sa, salen) < 0 )
{
perr_exit(“bind error”);
}
}
void Connect(int fd, const struct sockaddr* sa, socklen_t salen)
{
if ( connect(fd, sa, salen) < 0 )
{
perr_exit(“connect error”);
}
}
void Listen(int fd, int backlog)
{
if ( listen(fd, backlog) < 0 )
{
perr_exit(“listen error”);
}
}
int Socket(int family, int type, int protocol)
{
int n = socket(family, type, protocol);
if ( n < 0 )
{
perr_exit(“socket error”);
}
return n;
}
ssize_t Read(int fd, void* ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1)
{
if (errno == EINTR)
{
goto again;
}
else
{
return -1;
}
}
return n;
}
ssize_t Write(int fd, const void* ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1)
{
if (errno == EINTR)
{
goto again;
}
else
{
return -1;
}
}
return n;
}
void Close(int fd)
{
if (close(fd) == -1)
{
perr_exit(“close error”);
}
}
ssize_t Readn(int fd, void* vptr, size_t n)
{
size_t nleft;
ssize_t nread;
char* ptr;
ptr = vptr;
nleft = n;
while (nleft > 0)
{
if ( (nread = read(fd, ptr, nleft)) < 0 )
{
if (errno == EINTR)
{
nread = 0;
}
else
{
return -1;
}
}
else if (nread == 0)
{
break;
}
nleft -= nread;
ptr += nread;
}
}
ssize_t Writen(int fd, const void* vptr, size_t n)
{
size_t nleft;
ssize_t nwritten;
const char* ptr;
ptr = vptr;
nleft = n;
while (nleft > 0)
{
if ( (nwritten = write(fd, ptr, nleft)) <= 0)
{
if (nwritten < 0 && errno == EINTR)
{
nwritten = 0;
}
else
{
return -1;
}
}
nleft -= nwritten;
ptr += nwritten;
}
return n;
}
static ssize_t my_read(int fd, char* ptr)
{
static int read_cnt;
static char* read_ptr;
static char read_buf[100];
if (read_cnt <= 0)
{
again:
if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0 )
{
if (errno == EINTR)
{
goto again;
}
return -1;
}
else if (read_cnt == 0)
{
return 0;
}
read_ptr = read_buf;
}
read_cnt–;
*ptr = *read_ptr++;
return 1;
}
ssize_t Readline(int fd, void* vptr, size_t maxlen)
{
ssize_t n, rc;
char c, *ptr;
ptr = vptr;
for (n = 1; n < maxlen; n++)
{
if ( (rc = my_read(fd, &c)) == 1)
{
*ptr++ = c;
if (c == ‘\n’)
{
break;
}
}
else if (rc == 0)
{
*ptr = 0;
return n - 1;
}
else
{
return -1;
}
*ptr = 0;
return n;
}
}
服务端代码
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>
#include “wrap.h”
// 服务端要绑定的socket套接字文件
#define SERV_ADDR “foo.socket”
int main(int argc, char* argv[])
{
// 创建socket以 AF_UNIX 方式
int sock = Socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un srvaddr;
memset(&srvaddr, 0, sizeof(srvaddr));
srvaddr.sun_family = AF_UNIX;
strcpy(srvaddr.sun_path, SERV_ADDR);
/* offsetof 是一个宏，可以计算出第一个参数中的结构体中第二个参数的偏移位置 */
int len = offsetof(struct sockaddr_un, sun_path) +
strlen(srvaddr.sun_path);
// 删除当前目录下的socket文件，防止bind失败
unlink(SERV_ADDR);
Bind(sock, (struct sockaddr*)&srvaddr, len);
Listen(sock, 20);
printf(“Accept…..\n”);
struct sockaddr_un cntaddr;
int conn;
int size;
char buf[4096];
while (1)
{
len = sizeof(cntaddr);
conn = Accept(sock, (struct sockaddr*)&cntaddr, &len);
len -= offsetof(struct sockaddr_un, sun_path);
cntaddr.sun_path[len] = ‘\0’;
printf(“client bind filename %s\n”, cntaddr.sun_path);
// 接收
while ((size = read(conn, buf, sizeof(buf))) > 0)
{
for (int i = 0; i < size; i++)
{
buf[i] = toupper(buf[i]);
}
// 发送
Write(conn, buf, size);
}
}
return 0;
}
客户端代码
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <sys/un.h>
#include <stddef.h>
#include “wrap.h”
// 要连接的服务器socket套接字文件
#define SERV_ADDR “foo.socket”
// 客户端要绑定的socket套接字文件
#define CLIENT_ADDR “client.socket”
int main(int argc, char* argv[])
{
int len;
// 同样以 AF_UNIX 方式创建 socket
int sock = Socket(AF_UNIX, SOCK_STREAM, 0);
struct sockaddr_un srvaddr, cntaddr;
memset(&srvaddr, 0, sizeof(srvaddr));
memset(&cntaddr, 0, sizeof(cntaddr));
// 构建客户端的结构体
cntaddr.sun_family = AF_UNIX;
strcpy(cntaddr.sun_path, CLIENT_ADDR);
len = offsetof(struct sockaddr_un, sun_path) +
strlen(cntaddr.sun_path);
// 绑定客户端socket套接字文件
unlink(CLIENT_ADDR);
Bind(sock, (struct sockaddr*)&cntaddr, len);
// 构建要连接的服务端结构体
srvaddr.sun_family = AF_UNIX;
strcpy(srvaddr.sun_path, SERV_ADDR);
len = offsetof(struct sockaddr_un, sun_path) +
strlen(srvaddr.sun_path);
// 连接服务端
Connect(sock, (struct sockaddr*)&srvaddr, len);
char buf[4096];
while (fgets(buf, sizeof(buf), stdin) != NULL)
{
// 写
Write(sock, buf, strlen(buf));
// 读
len = read(sock, buf, sizeof(buf));
// 输出到屏幕
Write(STDOUT_FILENO, buf, len);
}
Close(sock);
return 0;
}