int
main(int argc, char **argv)
{
int fd1, fd2, *ptr1, *ptr2;
pid_t childpid;
struct stat stat;
if (argc != 2)
err_quit("usage: test3 <name>");
// shm_unlink(Px_ipc_name(argv[1]));
// fd1 = Shm_open(Px_ipc_name(argv[1]), O_RDWR | O_CREAT | O_EXCL, FILE_MODE);
shm_unlink(argv[1]);
fd1 = Shm_open(argv[1], O_RDWR | O_CREAT | O_EXCL, FILE_MODE);
Ftruncate(fd1, sizeof(int));
fd2 = Open("/etc/motd", O_RDONLY);
Fstat(fd2, &stat);
if ( (childpid = Fork()) == 0) {
/* child */
ptr2 = Mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd2, 0);
ptr1 = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE,
MAP_SHARED, fd1, 0);
printf("child: shm ptr = %p, motd ptr = %p\n", ptr1, ptr2);
sleep(5);
printf("shared memory integer = %d\n", *ptr1);
exit(0);
}
/* parent: mmap in reverse order from child */
ptr1 = Mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);
ptr2 = Mmap(NULL, stat.st_size, PROT_READ, MAP_SHARED, fd2, 0);
printf("parent: shm ptr = %p, motd ptr = %p\n", ptr1, ptr2);
*ptr1 = 777;
Waitpid(childpid, NULL, 0);
exit(0);
}
int
main(int argc, char *argv[])
{
int ret;
if (argc != 2)
err_quit("usage: ftw <starting-pathname>");
ret = myftw(argv[1], myfunc); /* does it all */
if ( (ntot = nreg + ndir + nblk + nchr + nfifo + nslink + nsock) == 0)
ntot = 1; /* avoid divide by 0; print 0 for all counts */
printf("regular files = %7ld, %5.2f %%\n", nreg, nreg*100.0/ntot);
printf("directories = %7ld, %5.2f %%\n", ndir, ndir*100.0/ntot);
printf("block special = %7ld, %5.2f %%\n", nblk, nblk*100.0/ntot);
printf("char special = %7ld, %5.2f %%\n", nchr, nchr*100.0/ntot);
printf("FIFOs = %7ld, %5.2f %%\n", nfifo, nfifo*100.0/ntot);
printf("symbolic links = %7ld, %5.2f %%\n", nslink,nslink*100.0/ntot);
printf("sockets = %7ld, %5.2f %%\n", nsock, nsock*100.0/ntot);
exit(ret);
}
int main(int argc, char *argv[])
{
int val;
if (argc != 2)
err_quit("usage: a.out <descriptor#>");
if ((val = fcntl(atoi(argv[1]), F_GETFL, 0)) < 0)
err_sys("fcntl error for fd %d", atoi(argv[1]));
switch (val &O_ACCMODE) {
case O_RDONLY:
printf("read only");
break;
case O_WRONLY:
printf("write only");
break;
case O_RDWR:
printf("read write");
break;
default:
err_dump("unknow access mode");
}
if (val &O_APPEND)
printf(", append");
if (val &O_NONBLOCK)
printf(", nonblocking");
#if defined(O_SYNC)
if (val &O_SYNC)
printf(", syncchronous write");
#endif
#if !defined(_POSIX_C_SOURCE) && defined(O_SYNC)
if (val &O_FSYNC)
printf(", syncchronous write");
#endif
putchar('\n');
exit(0);
}
int
main(int argc, char **argv)
{
int sockfd;
struct sockaddr_in servaddr;
if (argc != 2)
err_quit("usage: tcpcli <IPaddress>");
sockfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(7);
Inet_pton(AF_INET, argv[1], &servaddr.sin_addr);
Connect(sockfd, (SA *) &servaddr, sizeof(servaddr));
str_cli(stdin, sockfd); /* do it all */
exit(0);
}
int main(int argc, const char *argv[]) {
int fdin, fdout;
void *src, *dst;
size_t copysz;
struct stat sbuf;
off_t fsz = 0;
if (argc != 0)
err_quit("usage: %s <fromfile> <tofile>", argv[0]);
if ((fdin = open(argv[1], O_RDONLY)) < 0)
err_sys("can`t open %s for reading", argv[1]);
if ((fdout = open(argv[2], O_RDWR | O_CREAT | O_TRUNC,
FILE_MODE)) < 0)
err_sys("can`t creat %s for writing", argv[2]);
if (fstat(fdin, &sbuf) < 0)
err_sys("fstat error");
if (ftruncate(fdout, sbuf.st_size) < 0)
err_sys("ftruncate error");
while (fsz < sbuf.st_size) {
if ((sbuf.st_size - fsz) > COPYINCR)
copysz = COPYINCR;
else
copysz = sbuf.st_size - fsz;
if ((src = mmap(0, copysz, PROT_READ, MAP_SHARED,
fdin, fsz)) == MAP_FAILED)
err_sys("mmap error for input");
if ((dst = mmap(0, copysz, PROT_READ | PROT_WRITE,
MAP_SHARED, fdout, fsz)) == MAP_FAILED)
err_sys("mmap error for output");
memcpy(dst, src, copysz);
munmap(src, copysz);
munmap(dst, copysz);
fsz += copysz;
}
exit(0);
}
int
main(int argc, char **argv)
{
int fd;
if (argc != 2)
err_quit("usage: checkopts <device>");
fd = T_open(argv[1], O_RDWR, NULL);
T_bind(fd, NULL, NULL);
req = T_alloc(fd, T_OPTMGMT, T_ALL);
ret = T_alloc(fd, T_OPTMGMT, T_ALL);
xti_def_uchar_opt(fd, "T_IP_TOS", T_INET_IP, T_IP_TOS);
xti_def_uchar_opt(fd, "T_IP_TTL", T_INET_IP, T_IP_TTL);
xti_def_uscalar_opt(fd, "T_TCP_MAXSEG", T_INET_TCP, T_TCP_MAXSEG);
xti_def_uscalar_opt(fd, "T_TCP_NODELAY", T_INET_TCP, T_TCP_NODELAY);
exit(0);
}
int main(int argc, char **argv)
{
int c, id, oflag;
char *ptr;
size_t length;
oflag = SVSHM_MODE | IPC_CREAT;
while ((c = Getopt(argc, argv, "e")) != -1) {
switch (c) {
case 'e':
oflag |= IPC_EXCL;
break;
}
}
if (optind != argc - 2)
err_quit("Usage: get [-e] <pathname> <length>");
length = atoi(argv[optind + 1]);
id = Shmget(Ftok(argv[optind], 0), length, oflag);
ptr = Shmat(id, NULL, 0);
exit(0);
}
int main(int argc, char *argv[]) {
unsigned int value = 1;
int flags = O_RDWR | O_CREAT;
int c;
while ((c = getopt(argc, argv, "ei:")) != -1) {
switch (c) {
case 'e':
flags |= O_EXCL;
break;
case 'i':
value = atoi(optarg);
break;
}
}
if (optind != argc - 1)
err_quit("Usage: semcreate [-e] [-i initvalue] <name>");
sem_t *sem = sem_open(argv[optind], flags, FILE_MODE, value);
// sem_close(sem);
}
void server(int readfd, int writefd)
{
int fd;
ssize_t n;
char buff[MAXLINE+1];
/*从管道读路径名*/
if( (n = Read(readfd, buff, MAXLINE)) == 0)
err_quit("end-of -file while reading pathname");
buff[n] = '\0';
if( (fd = open(buff, O_RDONLY)) < 0){/*打开文件处理错误*/
snprintf(buff+n, sizeof(buff) - n, ":can't open, %s\n",
strerror(errno));
n = strlen(buff);
Write(writefd, buff, n);
}else{
while( (n = Read(fd, buff, MAXLINE)) > 0)/*把文件复制到管道*/
Write(writefd, buff, n);
Close(fd);
}
}
int
main(int argc, char const *argv[])
{
DIR *dp;
struct dirent *dirp;
if (argc != 2)
{
err_quit("usage: ls directory_name");
}
if ((dp = opendir(argv[1])) == NULL)
{
err_sys("can't open %s", argv[1]);
}
while((dirp = readdir(dp)) != NULL)
printf("%s\n", dirp->d_name);
closedir(dp);
exit(0);
}
ElemType Remove(List list, int position)
{
if (position < 0 || position > list->value - 1) {
DestroyList(list);
err_quit("Remove: position %d out of range, failed.", position);
}
Pos pos = list;
int i;
for (i = 0; i < position; ++i)
pos = pos->next;
Node p = pos->next;
ElemType temp = p->value;
pos->next = pos->next->next;
free(p);
list->value--;
return temp;
}
/**
* Copy identifier
*/
static char *
copy_identifier(const char *id)
{
size_t count = identifier_maxSize;
char *dest_buf = malloc(count + 1);
char *dest;
if (!dest_buf)
err_exit(ENOMEM, "copy_identifier");
else {
dest = &dest_buf[0];
}
while ((sw_isalnum(*id) || *id == '_') && count > 1) {
*dest++ = *id++, count--;
}
*dest = '\0';
if (count == 1)
err_quit("In copy_identifier: fatal: string was truncated!");
return (dest_buf);
}
int main(int argc, char **argv) {
int sockfd;
int n;
char recvline[MAXLINE+1];
socklen_t salen;
struct sockaddr *sa;
if (argc != 3)
err_quit("usage: daytimeudpcli <hostname/IPaddress> <service/port#>");
sockfd = Udp_client(argv[1], argv[2], (void **)&sa, &salen);
printf("sending to %s\n", Sock_ntop_host(sa, salen));
Sendto(sockfd, "", 1, 0, sa, salen); /* send 1-byte datagram */
n = Recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL);
recvline[n] = '\0';
Fputs(recvline, stdout);
exit(0);
}
uint8_t *
pdapi_recvmsg(int sock_fd,
int *rdlen,
SA *from,
int *from_len,
struct sctp_sndrcvinfo *sri,
int *msg_flags)
{
int rdsz,left,at_in_buf;
int frmlen=0;
if (sctp_pdapi_readbuf == NULL) {
sctp_pdapi_readbuf = (uint8_t *)Malloc(SCTP_PDAPI_INCR_SZ);
sctp_pdapi_rdbuf_sz = SCTP_PDAPI_INCR_SZ;
}
at_in_buf = Sctp_recvmsg(sock_fd, sctp_pdapi_readbuf, sctp_pdapi_rdbuf_sz,
from, from_len,
sri,msg_flags);
if(at_in_buf < 1){
*rdlen = at_in_buf;
return(NULL);
}
while((*msg_flags & MSG_EOR) == 0) {
left = sctp_pdapi_rdbuf_sz - at_in_buf;
if(left < SCTP_PDAPI_NEED_MORE_THRESHOLD) {
sctp_pdapi_readbuf = realloc(sctp_pdapi_readbuf, sctp_pdapi_rdbuf_sz+SCTP_PDAPI_INCR_SZ);
if(sctp_pdapi_readbuf == NULL) {
err_quit("sctp_pdapi ran out of memory");
}
sctp_pdapi_rdbuf_sz += SCTP_PDAPI_INCR_SZ;
left = sctp_pdapi_rdbuf_sz - at_in_buf;
}
rdsz = Sctp_recvmsg(sock_fd, &sctp_pdapi_readbuf[at_in_buf],
left, NULL, &frmlen, NULL, msg_flags);
at_in_buf += rdsz;
}
*rdlen = at_in_buf;
return(sctp_pdapi_readbuf);
}
int main(int argc, char *argv[])
{
int i, fd, n, maxnconn, flags, error;
char buf[MAXLINE];
fd_set rs, ws;
if (argc < 5)
err_quit("usage: web <#conn> <hostname> <homepage> <file1> ...");
maxnconn = atoi(argv[1]);
nfiles = min(argc - 4, MAXFILES);
for (i = 0; i < nfiles; i++) {
file[i].f_name = argv[i+4];
file[i].f_host = argv[2];
file[i].f_flags = 0;
}
printf("nfiles = %d\n", nfiles);
home_page(argv[2], argv[3]);
nlefttoread = nlefttoconn = nfiles;
nconn = 0;
Signal(SIGCHLD, sig_chld);
for (i = 0; i < maxnconn; i++) {
if (Fork() == 0) {
/*child */
printf("child %d started\n", getpid());
home_page(file[i].f_host, file[i].f_name);
exit(0);
}
file[i].f_flags = F_DONE;
}
while (nlefttoread > 0) {
pause();
}
printf("all finished\n");
return(0);
}
int main(int argc, char** argv)
{
int sockfd;
socklen_t len;
struct sockaddr_un addr1, addr2;
if(argc != 2)
{
err_quit("usage: unixbind <pathname>");
}
sockfd = Socket(AF_LOCAL, SOCK_STREAM, 0);
unlink(argv[1]);
bzero(&addr1, sizeof(addr1));
addr1.sun_family = AF_LOCAL;
strncpy(addr1.sun_path, argv[1], sizeof(addr1.sun_path)-1);
Bind(sockfd, (SA*)&addr1, SUN_LEN(&addr1));
len = sizeof(addr2);
Getsockname(sockfd, (SA*)&addr2, &len);
printf("bound name = %s, returned len = %d\n", addr2.sun_path, len);
exit(0);
}
ssp_lowner_t *ssp_lock_test (int fd, short type, short whence, off_t start,
off_t len)
{
flock_t lock;
static ssp_lowner_t lock_owner;
lock.l_type = type;
lock.l_whence = whence;
lock.l_start = start;
lock.l_len = len;
if (fcntl (fd, F_GETLK, &lock) == -1)
err_quit ("fcntl failed");
if (lock.l_type == F_UNLCK)
return (NULL);
lock_owner.sysid = lock.l_sysid;
lock_owner.pid = lock.l_pid;
return (&lock_owner);
}
main()
{
int fd[2], on, n;
char buf[100];
struct fcred cred;
if (socketpair(AF_LOCAL, SOCK_STREAM, 0, fd) < 0)
err_sys("socketpair error");
/* must set the socket option on the *receiving* socket */
on = 1;
Setsockopt(fd[1], 0, LOCAL_CREDS, &on, sizeof(on));
Write(fd[0], "hello, world\n", 13);
if ((n = recv_cred(fd[1], buf, sizeof(buf), &cred)) < 0)
err_sys("recv_cred error");
else if (n == 0)
err_quit("recv_cred, unexpected EOF");
buf[n] = 0; /* null terminate */
printf("data: %s", buf);
if (cred.fc_ngroups == 0)
printf("(no credentials returned)\n");
else {
printf("real user ID = %d\n", cred.fc_ruid);
printf("real group ID = %d\n", cred.fc_rgid);
printf("login name = %-*s\n", MAXLOGNAME, cred.fc_login);
printf("effective user ID = %d\n", cred.fc_uid);
printf("effective group ID = %d\n", cred.fc_gid);
printf("%d supplementary groups:", cred.fc_ngroups - 1);
for (n = 1; n < cred.fc_ngroups; n++) /* [0] is the egid */
printf(" %d", cred.fc_groups[n]);
printf("\n");
}
exit(0);
}
void child_main(int fd,socklen_t addrlen)
{
socklen_t clilen;
struct sockaddr *cliaddr;
int connfd;
cliaddr = malloc(addrlen);
for(;;)
{
clilen = addrlen;
my_lock_wait();
if((connfd = accept(listenfd,cliaddr,&clilen)) < 0)
{
if(errno = EINTR)
continue;
else
err_quit("accept error!");
}
my_lock_release();
web_child(connfd);
}
}
int main(int argc, char **argv) {
int connfd, n;
char recvline[MAXLINE + 1];
connfd = socket(AF_INET, SOCK_STREAM, 0);
struct sockaddr_in addr;
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_port = htons(13);
if (inet_pton(AF_INET, argv[1], &addr.sin_addr) < 0)
err_quit("inet_pton error");
if (connect(connfd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
err_sys("Connect error");
while ((n = read(connfd, recvline, MAXLINE)) > 0) {
recvline[n] = 0;
if (fputs(recvline, stdout) == EOF) {
err_sys("fputs error");
}
}
if (n < 0)
err_sys("read error");
exit(0);
}
int main(int argc, char **argv)
{
int sockfd = 0;
struct sockaddr_in servaddr;
if (argc < 2)
{
err_quit("usage: ./a.out <IPaddress>");
}
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT); //将一个无符号短整型的主机数值转换为网络字节顺序
my_inet_pton(AF_INET, MCAST_IP, &servaddr.sin_addr); //十进制IP转二进制
//创建一个套接字
sockfd = my_socket(AF_INET, SOCK_DGRAM, 0);
dg_cli(stdin, sockfd, (SA *) &servaddr, sizeof(servaddr));
exit(0);
}
/* next_blocked: toggle rightmost 'on' bit and return index of it, else 0 */
static int next_blocked(unsigned long *set)
{
unsigned long tmp;
int i;
long long mask;
if (*set == (sigset_t)0)
return 0; /* no bits set */
tmp = *set;
mask = (long long)1;
for (i = 0; i < 64; i++) {
if (tmp && mask)
break;
mask == mask << 1;
}
if (i == 64)
err_quit("error: loop completed"); /* should not get here */
mask = (long long)1 << i;
*set = *set && ~(mask); /* turn off bit */
return i;
}
/* barrier server */
int main(int argc, char *argv[])
{
char *req, *rel;
char *name, *prog;
int n;
prog = argv[0];
if (argc != 3)
err_quit("Usage: %s name size", prog);
name = argv[1];
n = atoi(argv[2]);
if (br_pipenames(name, &req, &rel) == -1)
err_sys("br_pipnames error");
if (br_createpipes(rel, req) != 0)
err_sys("br_createpipes error");
if (loop(n, req, rel) == -1)
err_sys("Server:");
exit(1); /* shouldn't get here */
}
int main(int argc, char *argv[])
{
int sockfd, n;
char recvline[MAXLINE + 1]; /* plus 1 for terminator */
socklen_t salen;
struct sockaddr *sa;
if (argc != 3)
err_quit("usage: daytimeudpcli1 <hostname/IPaddress>"
" <service/port#>");
sockfd = udp_client(argv[1], argv[2], (SA **)&sa, &salen);
printf("sending to %s\n", sock_ntop_host(sa, salen));
if (sendto(sockfd, " ", 1, 0, sa, salen) < 0)
err_sys("sendto error");
if ((n = recvfrom(sockfd, recvline, MAXLINE, 0, NULL, NULL)) < 0)
err_sys("recvfrom error");
recvline[n] = 0;
fputs(recvline, stdout);
exit(0);
}
int main(int argc, char *argv[])
{
struct sockaddr_in servaddr, cliaddr;
int sockfd;
if (argc != 2)
err_quit("Usage: %s <Port>", basename(argv[0]));
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(atoi(argv[1]));
Bind(sockfd, (SA *)&servaddr, sizeof(servaddr));
sigio_dg_echo(sockfd, (SA *)&cliaddr, sizeof(cliaddr));
exit(0);
}
int main(int argc, char *argv[])
{
time_t curtime;
int len;
char buf[PIPE_BUF];
int fd;
if (argc != 2)
err_quit("Usage: %s filename", argv[0]);
if ((fd = open(argv[1], O_WRONLY)) == -1)
err_sys("client: open logfile failed: %s", argv[1]);
curtime = time(NULL);
snprintf(buf, PIPE_BUF, "%d: %s", (int)getpid(), ctime(&curtime));
len = strlen(buf);
if (r_write(fd, buf, len) != len)
err_sys("client: failed to write");
r_close(fd);
return 0;
}
int
main(int argc, char **argv)
{
int i, nprocs;
pid_t childpid[MAXNPROC];
if (argc != 3)
err_quit("usage: incr_rwlock5 <#loops> <#processes>");
nloop = atoi(argv[1]);
nprocs = min(atoi(argv[2]), MAXNPROC);
/* 4get shared memory for parent and children */
shared = My_shm(sizeof(struct shared));
/* 4initialize the read-write lock and obtain write lock */
Rwlock_init(&shared->rwlock, USYNC_PROCESS, NULL);
Rw_wrlock(&shared->rwlock);
/* 4create all the children */
for (i = 0; i < nprocs; i++) {
if ( (childpid[i] = Fork()) == 0) {
incr(NULL);
exit(0);
}
}
/* 4parent: start the timer and release the write lock */
Start_time();
Rw_unlock(&shared->rwlock);
/* 4wait for all the children */
for (i = 0; i < nprocs; i++) {
Waitpid(childpid[i], NULL, 0);
}
printf("microseconds: %.0f usec\n", Stop_time());
if (shared->counter != nloop * nprocs)
printf("error: counter = %ld\n", shared->counter);
exit(0);
}
int
udp_server_reuseaddr(const char *host, const char *serv, socklen_t *addrlenp)
{
int sockfd, n;
const int on = 1;
struct addrinfo hints, *res, *ressave;
bzero(&hints, sizeof(struct addrinfo));
hints.ai_flags = AI_PASSIVE;
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
if ( (n = getaddrinfo(host, serv, &hints, &res)) != 0)
err_quit("udp_server error for %s, %s: %s",
host, serv, gai_strerror(n));
ressave = res;
do {
sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (sockfd < 0)
continue; /* error, try next one */
Setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
if (bind(sockfd, res->ai_addr, res->ai_addrlen) == 0)
break; /* success */
Close(sockfd); /* bind error, close and try next one */
} while ( (res = res->ai_next) != NULL);
if (res == NULL) /* errno from final socket() or bind() */
err_sys("udp_server error for %s, %s", host, serv);
if (addrlenp)
*addrlenp = res->ai_addrlen; /* return size of protocol address */
freeaddrinfo(ressave);
return(sockfd);
}
int
main(int argc, char *argv[])
{
key_t key;
long qid;
size_t nbytes;
struct mymesg m;
if (argc != 3)
err_quit("usage: sendmsg KEY message\n");
key = strtol(argv[1], NULL, 0);
if ((qid = msgget(key, 0)) < 0)
err_sys("can't open queue key %s", argv[1]);
memset(&m, 0, sizeof(m));
strncpy(m.mtext, argv[2], MAXMSZ - 1);
nbytes = strlen(m.mtext);
m.mtype = 1;
if (msgsnd(qid, &m, nbytes, 0) < 0)
err_sys("can't send message");
exit(0);
}
void getNodeName(){
struct hwa_info *hwa, *hwahead;
struct sockaddr *sa;
struct hostent *hptr;
for (hwahead = hwa = get_hw_addrs(); hwa != NULL; hwa = hwa->hwa_next) {
if(strcmp(hwa->if_name, "eth0") == 0 || strcmp(hwa->if_name, "wlan0") == 0 ){
if ( (sa = hwa->ip_addr) != NULL)
myNodeIP = Sock_ntop_host(sa, sizeof(*sa));
}
}
myNodeIP = Sock_ntop_host(sa, sizeof(*sa));
if(inet_aton(myNodeIP, &ip_list[0]) != 0){
if((hptr = gethostbyaddr(&ip_list[0], sizeof(struct in_addr), AF_INET)) == NULL){
err_quit ( "gethostbyaddress error for IP address: %s: %s" , myNodeIP, hstrerror(h_errno));
debug("errno: %s", strerror(errno));
}
printf("The server host name is %s.\n", hptr->h_name);
myNodeName =(char*) malloc(strlen(hptr->h_name));
strcpy(myNodeName,hptr->h_name);
}
}
