UNIX本地套接字 示例

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

#if 0
#define SOCK_UNIX_FILE "/tmp/video1_sock"
#else
#define SOCK_UNIX_FILE "/tmp/video_sock"
#endif
#define MAX_TRANSMIT_DATA_LEN 10240
#define S_TIME_OUT 2000 //2s

int tcp_write(int socketfd, char* buf, int len,unsigned int timeout_ms)
{
int ret;
int total_lenth = 0;
int len_remain = len;
char *write_position = buf;
struct timeval timeout;
fd_set  wset, eset;
int status = 1;

timeout.tv_sec =timeout_ms/1000;
timeout.tv_usec = timeout_ms%1000;
printf("%s  %d \n",__func__,__LINE__);
while(1){

FD_ZERO(&wset);
FD_ZERO(&eset);
FD_SET(socketfd, &eset);
FD_SET(socketfd, &wset);
ret = select(socketfd+1, NULL, &wset, &eset, &timeout);
printf("%s  %d \n",__func__,__LINE__);
if( ( timeout.tv_sec == 0)  && ( timeout.tv_usec == 0) ){
//timeout
printf(" write timeout \n");
break;
}
printf("%s  %d \n",__func__,__LINE__);
if(FD_ISSET(socketfd, &wset)){
printf("%s  %d \n",__func__,__LINE__);
ret = send(socketfd, write_position, len_remain, 0);
printf("%s  %d \n",__func__,__LINE__);
if(ret < 0){
printf(" write err \n");
return -1;
}

if(ret == 0){
printf(" write ==0 ... \n");

}
printf("%s  %d \n",__func__,__LINE__);
write_position += ret;
total_lenth += ret;
len_remain -= ret;
if(0 == len_remain) {
break;
}

}

if(FD_ISSET(socketfd, &eset)){
printf("write err \n");
break;

}

}

//printf("write %d \n",len -len_remain);
return len -len_remain ;
}

int tcp_read(int socketfd, char* buf, int len,unsigned int timeout_ms)
{
int ret;
int total_lenth = 0;
int len_remain = len;
char *read_position = buf;
struct timeval timeout;
fd_set  rset, eset;

timeout.tv_sec =timeout_ms/1000;
timeout.tv_usec = timeout_ms%1000;
//printf("read timeout set %d %d\n",timeout.tv_sec,timeout.tv_usec);

while(1){

FD_ZERO(&rset);
FD_ZERO(&eset);
FD_SET(socketfd, &eset);
FD_SET(socketfd, &rset);

ret = select(socketfd+1, &rset, NULL, &eset, &timeout);

if( ( timeout.tv_sec == 0)  && ( timeout.tv_usec == 0) ){
//timeout
//printf(" read timeout \n");
break;
}

if(FD_ISSET(socketfd, &rset)){
ret = recv(socketfd, read_position, len_remain, 0);
if(ret < 0){
//error
//printf("read err\n");
break;
}
if(ret == 0){
//printf(" read %d..\n",ret);
// peer close
//printf(" peer close ?\n");
break;
}
//printf(" read %d...\n",ret);

read_position += ret;
total_lenth += ret;
len_remain -= ret;
if(len_remain <=0) break;

}

if(FD_ISSET(socketfd, &eset)){
printf("read err \n");
break;

}

}
//printf("time remain %d %d\n",timeout.tv_sec,timeout.tv_usec);
return total_lenth;
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <signal.h>
#include <errno.h>

int peer_sock_status = 0;
static void sig_handle(int signo)
{
switch(signo)
{

case SIGTERM:
printf("receive SIGTERM!\n");
exit(0);
break;
case SIGKILL:
printf("receive SIGKILL!\n");
exit(0);
break;
case SIGINT:
printf("\nreceive Ctrl+c!Then, the server will exit after 3 seconds !\n");
sleep(3);
exit(0);
break;
case SIGALRM:
printf("receive SIGALRM!\n");
break;
case SIGILL:
printf("receive SIGILL!\n");
break;
case SIGSEGV:
printf("receive SIGSEGV!\n");
break;
case SIGPIPE:
peer_sock_status = 0;
printf("receive SIGPIPE!\n");
break;
default:
printf("receive unknown signal(%d)!\n", signo);
break;
}
}

int main (int argc, char *argv[])
{
int server_sockfd, client_sockfd;
int server_len, client_len;
static int i_tmp = 0;
struct sockaddr_un server_address;
struct sockaddr_un client_address;
int i, bytes;
char ch_send, ch_recv;
char s_buf[MAX_TRANSMIT_DATA_LEN];
char r_buf[8];
unsigned int len = 0;
unlink (SOCK_UNIX_FILE);//delete the file link for the function of bind

server_sockfd = socket (AF_UNIX, SOCK_STREAM, 0);

server_address.sun_family = AF_UNIX;

strcpy (server_address.sun_path, SOCK_UNIX_FILE);

server_len = sizeof (server_address);

bind (server_sockfd, (struct sockaddr *)&server_address, server_len);

listen (server_sockfd, 5);//the num of the client is five

printf ("Server is waiting for client connect...\n");

client_len = sizeof (client_address);
#if 1
for(i=1; i<=SIGIO; i++) signal(i, sig_handle);
#endif
accept_again:
if(i_tmp != 0)
{
printf ("\nServer is waiting for client connect...\n");
}
client_sockfd = accept (server_sockfd, (struct sockaddr *)&server_address, (socklen_t *)&client_len);

if (client_sockfd == -1) {
perror ("accept");
exit (EXIT_FAILURE);
}
peer_sock_status =1;
printf ("The server is waiting for client data...\n");
strcpy(s_buf,"the tcp send stream to jss_server");

while(1){

memset(s_buf,0,MAX_TRANSMIT_DATA_LEN);
memset(r_buf,0,8);
sprintf(s_buf,"the %dth packet to jss_server !",i_tmp++);
printf("write data :");

if ((bytes = tcp_write(client_sockfd, s_buf, MAX_TRANSMIT_DATA_LEN,S_TIME_OUT)) <= 0) {
perror ("WWrite");
goto accept_again;

}

len += bytes;
printf(" %d %d\n",bytes,len);

usleep(2);
printf(" %s %d The status of the client is %s \n",__FUNCTION__,__LINE__,r_buf);
}
close (client_sockfd);
unlink ("server socket");
goto accept_again;
}

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <sys/un.h>
#include <unistd.h>
#include <stdlib.h>

#if 1
#define SOCK_UNIX_FILE "/tmp/video1_sock"
#else
#define SOCK_UNIX_FILE "/tmp/video_sock"
#endif
#define MAX_TRANSMIT_DATA_LEN 10240
#define C_TIME_OUT 2000 //2s

int tcp_read(int socketfd, char* buf, int len,unsigned int timeout_ms)
{
int ret;
int total_lenth = 0;
int len_remain = len;
char *read_position = buf;
struct timeval timeout;
fd_set  rset, eset;

timeout.tv_sec =timeout_ms/1000;
timeout.tv_usec = timeout_ms%1000;
//printf("read timeout set %d %d\n",timeout.tv_sec,timeout.tv_usec);

do{

FD_ZERO(&rset);
FD_ZERO(&eset);
FD_SET(socketfd, &eset);
FD_SET(socketfd, &rset);

ret = select(socketfd+1, &rset, NULL, &eset, &timeout);

if( ( timeout.tv_sec == 0)  && ( timeout.tv_usec == 0) ){
//timeout
//printf(" read timeout \n");
break;
}

if(FD_ISSET(socketfd, &rset)){
ret = recv(socketfd, read_position, len_remain, 0);
if(ret < 0){
//error
//printf("read err\n");
break;
}
if(ret == 0){
//printf(" read %d..\n",ret);
// peer close
//printf(" peer close ?\n");
break;
}
//printf(" read %d...\n",ret);

read_position += ret;
total_lenth += ret;
len_remain -= ret;
if(len_remain <=0) break;

}

if(FD_ISSET(socketfd, &eset)){
printf("read err \n");
break;

}

}while(0);

//printf("time remain %d %d\n",timeout.tv_sec,timeout.tv_usec);
return total_lenth;
}

int tcp_write(int socketfd, char* buf, int len,unsigned int timeout_ms)
{
int ret;
int total_lenth = 0;
int len_remain = len;
char *write_position = buf;
struct timeval timeout;
fd_set  wset, eset;

timeout.tv_sec =timeout_ms/1000;
timeout.tv_usec = timeout_ms%1000;

while(1){

FD_ZERO(&wset);
FD_ZERO(&eset);
FD_SET(socketfd, &eset);
FD_SET(socketfd, &wset);
ret = select(socketfd+1, NULL, &wset, &eset, &timeout);

if( ( timeout.tv_sec == 0)  && ( timeout.tv_usec == 0) ){
//timeout
printf(" write timeout \n");
break;
}

if(FD_ISSET(socketfd, &wset)){
ret = send(socketfd, write_position, len_remain, 0);

if(ret < 0){
printf(" write err \n");

}

if(ret == 0){
printf(" write ==0 ... \n");

}

write_position += ret;
total_lenth += ret;
len_remain -= ret;
if(0 == len_remain) {
break;
}

}

if(FD_ISSET(socketfd, &eset)){
printf(" err \n");
break;

}

}

//printf("write %d \n",len -len_remain);
return len -len_remain ;
}

int main (int argc, char *argv[])
{

struct sockaddr_un address;
int sockfd;
int len;
int i, bytes;
int result;
char ch_recv, ch_send;
char r_buf[MAX_TRANSMIT_DATA_LEN];
char s_buf[8];
strcpy(s_buf,"LIVING");
len = 0;

if ((sockfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
perror ("socket");
exit (EXIT_FAILURE);
}

address.sun_family = AF_UNIX;
strcpy (address.sun_path, SOCK_UNIX_FILE);
len = sizeof (address);

result = connect (sockfd, (struct sockaddr *)&address, len);
if (result == -1) {
printf ("ensure the server is up\n");
perror ("connect");
exit (EXIT_FAILURE);
}
printf("%s %d Connect succeed !\n",__FUNCTION__,__LINE__);

while(1){
//memset(r_buf,0,MAX_TRANSMIT_DATA_LEN);
bytes = tcp_read (sockfd, r_buf, MAX_TRANSMIT_DATA_LEN,C_TIME_OUT);
//bytes = recv(sockfd, r_buf, 10240, 0);
if (bytes <= 0) {
perror ("read");
exit (EXIT_FAILURE);
}

len +=bytes;
printf("read data %d, %d\n",bytes,len);

//sleep(5);
}

close (sockfd);

return (0);

}