void urg_handler(int signo) {
int n;
char c;
if ( (n = recv(server_fd, &c, 1, MSG_OOB)) < 0) {
if (errno != EWOULDBLOCK) ERR_EXIT("recv error");
}
printf("receive heart beat packet from server\n");
nprobes = 0;
return ;
}
InetAddress InetAddress::getLocalAddress(int sockfd)
{
struct sockaddr_in addr;
socklen_t len = sizeof addr;
if(::getsockname(sockfd, (SA*)&addr, &len) == -1)
{
ERR_EXIT("getsockname");
}
return InetAddress(addr);
}
// 开启套接字fd接收带外数据的功能
void activate_oobinline(int fd)
{
int oob_inline = 1;
int ret;
ret = setsockopt(fd, SOL_SOCKET, SO_OOBINLINE, &oob_inline, sizeof(oob_inline));
if (ret == -1)
{
ERR_EXIT("setsockopt");
}
}
int main(int argc, const char *argv[])
{
int fd = open("3.txt", O_WRONLY | O_CREAT | O_EXCL, 0666);
if(fd == -1)
ERR_EXIT("open");
char buf[1024] = "wang si ke shi yi ge hao gu niang.";
write(fd, buf, sizeof(buf));
close(fd);
return 0;
}
int main(int argc, const char *argv[])
{
int peerfd = socket(PF_INET, SOCK_STREAM, 0);
if(peerfd == -1)
ERR_EXIT("socket");
struct sockaddr_in peeraddr;
peeraddr.sin_family = AF_INET;
peeraddr.sin_port = htons(8080);
peeraddr.sin_addr.s_addr = inet_addr("127.0.0.1");
if((connect(peerfd, (struct sockaddr*)&peeraddr, sizeof peeraddr)) < 0)
ERR_EXIT("connect");
do_service(peerfd);
close(peerfd);
return 0;
}
/*
* === FUNCTION ======================================================================
* Name: myftw
* Description:
* =====================================================================================
*/
static int myftw(char *pathname,Myfunc *func){
fullpath = malloc(sizeof(char)*pathlen);
if(pathlen <= strlen(pathname)){
pathlen = strlen(pathname) * 2;
if((fullpath = realloc(fullpath,pathlen))==NULL)
ERR_EXIT("relloc failed");
}
strcpy(fullpath,pathname);
return(dopath(func));
}
int main(int argc, const char *argv[])
{
if(signal(SIGPIPE, SIG_IGN) == SIG_ERR)
ERR_EXIT("signal");
int fd_server;
preprocess(&fd_server);
do_epoll(fd_server);
close(fd_server);
return 0;
}
int TcpClient(const char* host, uint64_t port)//return peerfd
{
int peerfd = socket(PF_INET, SOCK_STREAM, 0);
if(peerfd == -1)
ERR_EXIT("socket");
if(port == 0)//if port=0 then no need to bind
return peerfd;
SetAddReuse(peerfd, 1);//add reuse
SAI addr;
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = inet_addr(host);
if(bind(peerfd, (SA*)&addr, sizeof addr) == -1)
ERR_EXIT("bind client");
return peerfd;
}
void SetPortReuse(int sockfd, int optval)//port reuse
{
#ifdef SO_REUSEPORT
int on = (optval != 0) ? 1 : 0;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) < 0)
ERR_EXIT("setsockopt SO_REUSEPORT");
#else
fprintf(stderr, "SO_REUSEPORT is not supported.\n");
#endif //SO_REUSEPORT
}
/*
* Init dump tool backends
*/
void dt_init(void)
{
struct dt *dt;
int i = 0;
while ((dt = dt_vec[i])) {
g.fh = zg_open(g.opts.device, O_RDONLY, ZG_CHECK);
if (!S_ISBLK(g.fh->sb.st_mode))
ERR_EXIT("Please specify DASD or SCSI device node"
"(e.g. /dev/dasdd or /dev/sda )");
if (dt->init() == 0) {
l.dt = dt;
return;
}
zg_close(g.fh);
i++;
}
ERR_EXIT("No dump tool found on \"%s\"", g.opts.device);
}
int main(int argc, char *argv[])
{
int msgid;
msgid = msgget(1234, 0);
if (msgid == -1)
ERR_EXIT("msgget");
echo_cli(msgid);
return 0;
}
void set_minprivilage(void)
{
struct passwd* pwd = getpwnam("nobody");
if ( NULL == pwd )
ERR_EXIT("getpwnam error");
if ( -1 == setegid(pwd->pw_gid))
ERR_EXIT("setegid error");
if ( -1 == seteuid(pwd->pw_uid))
ERR_EXIT("seteuid error");
struct __user_cap_header_struct cap_header;
cap_header.version = _LINUX_CAPABILITY_VERSION_1;
cap_header.pid = 0;
struct __user_cap_data_struct cap_data;
cap_data.effective = cap_data.permitted = 1 << CAP_NET_BIND_SERVICE;
cap_data.inheritable = 0;
if ( -1 == capset(&cap_header,&cap_data))
ERR_EXIT("capset error");
}
int main(int argc, const char *argv[])
{
int iret;
if(argc == 1){
ERR_EXIT("too few args");
}else{
iret = mkdir(argv[1], 0777);
}
return 0;
}
void priv_sock_init(session_t *sess)
{
int fds[2];
/* 创建一对UNIX域的套接字，用于进程间通信 */
if(socketpair(PF_UNIX, SOCK_STREAM, 0, fds) == -1)
ERR_EXIT("socketpair");
sess->nobody_fd = fds[0];
sess->proto_fd = fds[1];
}
int main(int argc, const char *argv[])
{
int fd = open("test.txt", O_RDONLY, 0666);
if(fd == -1)
ERR_EXIT("open");
char buf[1024] = {0};
int ret = read(fd, buf, 5);
if(ret == -1)
ERR_EXIT("read");
printf("buf ---- %s\n", buf);
off_t len = lseek(fd, 0, SEEK_CUR);
printf("len ---- %d\n", (int)len);
len = lseek(fd, 5, SEEK_CUR);
printf("len ---- %d\n", (int)len);
return 0;
}
int main(int argc, char* argv[])
{
int peerfd = socket(AF_INET, SOCK_STREAM, 0);
if(peerfd == -1)
{
ERR_EXIT("socket");
}
struct sockaddr_in client_addr;
memset(client_addr, 0, sizeo(client_addr));
client_addr.sin_family = AF_INET;
client_addr.sin_addr.s_addr = inet_addr("192.168.175.128");
client_addr.sin_port = htons(9999);
socklen_t sock_len = sizeof(client_addr);
if(-1 == connect(sockdf, (struct sockaddr&)*client_addr, sock_len))
{
ERR_EXIT("connect");
}
do_service(peerfd);
}
int sem_setval(int semid, int val)
{
union semun su;
su.val = val;
int ret;
ret = semctl(semid, 0, SETVAL, su);
if(ret == -1)
ERR_EXIT("semctl");
return 0;
}
int main() {
int listen_fd;
// create a socket for listening
if ((listen_fd = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
ERR_EXIT("socket function return negative");
}
unlink(SOCKET_FILE);
struct sockaddr_un server_addr;
memset(&server_addr, 0, sizeof(server_addr));
server_addr.sun_family = AF_UNIX;
strcpy(server_addr.sun_path, SOCKET_FILE);
// bind a address to the listening socket for clients to connect
if (bind(listen_fd, (struct sockaddr*) &server_addr, sizeof(server_addr)) < 0) {
ERR_EXIT("bind error");
}
// start to listen for connecting request
if (listen(listen_fd, SOMAXCONN) < 0) {
ERR_EXIT("listen error");
}
while (1) {
// create a new socket, which implies a new connection between server and client
int conn_fd = accept(listen_fd, NULL, NULL);
if (conn_fd == -1) {
if (conn_fd == EINTR) continue;
ERR_EXIT("acccept error");
}
pid_t pid = fork();
if (pid == -1) {
ERR_EXIT("fork error");
}
if (pid == 0) {
close(listen_fd);
echo_server(conn_fd);
exit(EXIT_SUCCESS);
}
close(conn_fd);
}
return 0;
}
int main(void)
{
int sock;
if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
ERR_EXIT("socket");
echo_cli(sock);
return 0;
}
long get_time_sec()
{
int ret = gettimeofday(&s_curr_time, NULL);
if (ret < 0)
{
ERR_EXIT("gettimeofday");
}
return s_curr_time.tv_sec;
}
int32_t Recv_Len(int sockfd)//recv length first
{
int32_t temp;
int nread = Readn(sockfd, &temp, sizeof(int32_t));
if(nread == -1)
ERR_EXIT("Recv_Len");
else if(nread < sizeof(int32_t))
return 0;
return ntohl(temp);//mistake for ntohs
}
int main( void )
{
int fd;
struct sockaddr_in addr;
memset(&addr, 0x00, sizeof(addr));
if ( (fd=socket(PF_INET, SOCK_STREAM, 0)) == -1)
ERR_EXIT("socket");
addr.sin_family = AF_INET;
addr.sin_port = htons(9999);
inet_aton("192.168.0.200", &addr.sin_addr);
if ( connect(fd, (struct sockaddr*)&addr, sizeof(addr)) == -1)
ERR_EXIT("connect");
echo_cli(fd);
close(fd);
}
SAI GetPeerAddr(int peerfd)//get peerfd addr
{
SAI addr;
memset(&addr, 0, sizeof addr);
addr.sin_family = AF_INET;
socklen_t len = sizeof addr;
if(getpeername(peerfd, (SA*)&addr, &len) == -1)
ERR_EXIT("getpeername");
return addr;
}
int server_listen(const char * name) {
int fd, len, rval;
struct sockaddr_un un;
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) ERR_EXIT("socket");
unlink(name);
memset(&un, 0, sizeof(un));
un.sun_family = AF_UNIX;
strcpy(un.sun_path, name);
len = offsetof(struct sockaddr_un, sun_path) + strlen(name);
if (bind(fd, (struct sockaddr*)&un, len) < 0) ERR_EXIT("bind");
if (listen(fd, QLEN) < 0) ERR_EXIT("listen");
return fd;
}
void poll_accept(Poll_t *pol)
{
if(pol->clients_[0].revents & POLLIN)
{
int peerfd = accept(pol->listenfd_, NULL, NULL);
if(peerfd == -1)
ERR_EXIT("accept");
poll_add_fd(pol, peerfd);
}
}
static struct shutdown_action *shutdown_action_get(const char *action)
{
int i;
for (i = 0; shutdown_action_vec[i]; i++) {
if (strcmp(action, shutdown_action_vec[i]->name) == 0)
return shutdown_action_vec[i];
}
ERR_EXIT("Unknown shutdown action \"%s\" specified", action);
}
int main(void)
{
int fd;
fd = open("hole.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1)
ERR_EXIT("open error");
write(fd, "ABCDE", 5);
int ret = lseek(fd, 1024*1024*1024, SEEK_CUR);
if (ret == -1)
ERR_EXIT("lseek error");
write(fd, "hello", 5);
close(fd);
return 0;
}
int main(void)
{
int sock;
if ((sock = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
ERR_EXIT("socket error");
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("bind error");
echo_ser(sock);
return 0;
}
int main(void)
{
int sock;
if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
ERR_EXIT("socket error");
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
if (connect(sock, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("connect error");
char sendbuf[1024] = "I'm select\n";
char recvbuf[1024] = {0};
write(sock, sendbuf, strlen(sendbuf));
int maxfd = sock;
fd_set rset;
FD_ZERO(&rset);
FD_SET(sock, &rset);
while (1) {
int nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
if (nready == -1)
ERR_EXIT("select error");
if (nready == 0)
continue;
if (FD_ISSET(sock, &rset)) {
read(sock, recvbuf, sizeof(recvbuf));
fputs(recvbuf, stdout);
break;
}
}
close(sock);
return 0;
}
int MakeServer(int backlog)
{
int ret;
evutil_socket_t sockfd = socket(PF_INET,SOCK_STREAM,0);
if(sockfd < 0)
ERR_EXIT("create socket");
struct sockaddr_in addr;
addr.sin_port = htons(81);
addr.sin_family = AF_INET;
if((ret = inet_pton(PF_INET,"0.0.0.0",&(addr.sin_addr))) < 0)
ERR_EXIT("convert to ip");
int value = 1;
if((ret = setsockopt(sockfd,SOL_SOCKET,SO_REUSEADDR,&value,sizeof(value))) < 0)
ERR_EXIT("set socket");
if((ret = bind(sockfd,(struct sockaddr*)&addr,sizeof(struct sockaddr))) < 0)
ERR_EXIT("bind socket");
if((ret = listen(sockfd,backlog)) < 0)
ERR_EXIT("listen socket");
return sockfd;
}
