void
start_connect(struct file *fptr)
{
int fd, flags, n;
struct addrinfo *ai;
ai = Host_serv(fptr->f_host, SERV, 0, SOCK_STREAM);
fd = Socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
fptr->f_fd = fd;
printf("start_connect for %s, fd %d\n", fptr->f_name, fd);
/* 4Set socket nonblocking */
flags = Fcntl(fd, F_GETFL, 0);
Fcntl(fd, F_SETFL, flags | O_NONBLOCK);
/* 4Initiate nonblocking connect to the server. */
if ( (n = connect(fd, ai->ai_addr, ai->ai_addrlen)) < 0) {
if (errno != EINPROGRESS)
err_sys("nonblocking connect error");
fptr->f_flags = F_CONNECTING;
FD_SET(fd, &rset); /* select for reading and writing */
FD_SET(fd, &wset);
if (fd > maxfd)
maxfd = fd;
} else if (n >= 0) /* connect is already done */
write_get_cmd(fptr); /* write() the GET command */
}
/* use nonblock for connect */
int connect_nob(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen, int nsec)
{
int flags, n, error;
socklen_t len;
struct timeval tval;
fd_set rset, wset;
flags = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
error = 0;
/* when socket is nonblock connect return EINPROGRESS and three ways hand shake is still running */
if ((n = connect(sockfd, servaddr, addrlen)) < 0)
{
if (errno != EINPROGRESS) /* ignore the mistake */
return (-1);
} /* nonbalck state the socket is connected now */
/* this might happen some times */
if (n == 0)
goto done;
FD_ZERO(&rset);
FD_SET(sockfd, &rset);
wset = rset;
tval.tv_sec = nsec;
tval.tv_usec = 0;
if ((n = select(sockfd+1, &rset, &wset, NULL, nsec ? &tval : NULL)) < 0)
err_sys("select error");
else if (n == 0) /* select time out */
{
Close(sockfd);
errno = ETIMEDOUT;
err_sys("select timeout");
}
if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset))
{
len = sizeof(error);
Getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len);
}
else
err_quit("select error: sockfd not set");
done: /* wether n==0 or not bellow will excuted */
Fcntl(sockfd, F_SETFL, flags); /* set back to block */
if (error) /* connect error */
{
Close(sockfd);
errno = error;
return (-1);
}
return (0);
}
int ASControl::connect_nonb(int sockfd, const SA *saptr, socklen_t salen, int nsec)
{
int flags, n, error;
socklen_t len;
fd_set rset, wset;
struct timeval tval;
flags = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
error = 0;
if((n = connect(sockfd, saptr, salen)) < 0)
if (errno != EINPROGRESS)
return (-1);
/* Do whatever we want while the connect is taking place. */
if (n == 0)
goto done; /* connect completed immediately */
FD_ZERO(&rset);
FD_SET(sockfd, &rset);
wset = rset;
tval.tv_sec = nsec;
tval.tv_usec = 0;
if ( (n = Select(sockfd + 1, &rset, &wset, NULL, nsec ? &tval : NULL)) == 0)
{
close(sockfd); /* timeout */
errno = ETIMEDOUT;
return (-1);
}
if (FD_ISSET(sockfd, &rset) || FD_ISSET(sockfd, &wset))
{
len = sizeof(error);
if (getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &error, &len) < 0)
return (-1); /* Solaris pending error */
}
else
err_quit("select error: sockfd not set");
done:
Fcntl(sockfd, F_SETFL, flags); /* restore file status flags */
if (error)
{
close(sockfd); /* just in case */
errno = error;
return (-1);
}
return (0);
}
int
__send (int fd, const void *buf, ssize_t buflen, int flags)
{
if (__libc_newsockets) {
long r = Fsendto (fd, buf, buflen, flags, NULL, 0);
if (r != -ENOSYS) {
if (r < 0) {
__set_errno (-r);
return -1;
}
return r;
} else
__libc_newsockets = 0;
}
{
struct send_cmd cmd;
long r;
cmd.cmd = SEND_CMD;
cmd.buf = buf;
cmd.buflen = buflen;
cmd.flags = flags;
r = Fcntl (fd, (long) &cmd, SOCKETCALL);
if (r < 0) {
__set_errno (-r);
return -1;
}
return r;
}
}
int main(int argc, char **argv)
{
int n;
char buff[100];
if (argc == 2)
listenfd = Tcp_listen(NULL, argv[1], NULL);
else if (argc == 3)
listenfd = Tcp_listen(argv[1], argv[2], NULL);
else
err_quit("usage: tcprecv01 [ <host> ] <port#>");
connfd = Accept(listenfd, NULL, NULL);
Signal(SIGURG, sig_urg);
Fcntl(connfd, F_SETOWN, getpid());// set shuzu
for ( ; ; ) {
if ( (n = Read(connfd, buff, sizeof(buff)-1)) == 0) {
printf("received EOF\n");
exit(0);
}
buff[n] = 0; /* null terminate */
printf("read %d bytes: %s\n", n, buff);
}
}
/*
** Description
** Get program name and command line
*/
static
void
get_loadinfo (WORD pid,
WORD fnamelen,
BYTE * cmdlin,
BYTE * fname)
{
BYTE pname[30];
_DTA *olddta,newdta;
olddta = Fgetdta();
Fsetdta(&newdta);
sprintf(pname,"u:\\proc\\*.%03d",pid);
if(Fsfirst(pname,0) == 0) {
LONG fd;
sprintf(pname,"u:\\proc\\%s",newdta.dta_name);
if((fd = Fopen(pname,0)) >= 0) {
struct ploadinfo li;
li.fnamelen = fnamelen;
li.cmdlin = cmdlin;
li.fname = fname;
Fcntl((WORD)fd,&li,PLOADINFO);
Fclose((WORD)fd);
}
}
Fsetdta(olddta);
}
int
__setsockopt (int fd, int level, int optname, void *optval, socklen_t optlen)
{
if (__libc_newsockets) {
long r = Fsetsockopt (fd, level, optname, optval, optlen);
if (r != -ENOSYS) {
if (r < 0) {
__set_errno (-r);
return -1;
}
return 0;
} else
__libc_newsockets = 0;
}
{
struct setsockopt_cmd cmd;
long r;
cmd.cmd = SETSOCKOPT_CMD;
cmd.level = level;
cmd.optname = optname;
cmd.optval = optval;
cmd.optlen = optlen;
r = Fcntl (fd, (long) &cmd, SOCKETCALL);
if (r < 0) {
__set_errno (-r);
return -1;
}
return 0;
}
}
int main(int argc, char const *argv[])
{
int n;
char buff[100];
if (argc==2)
{
listenfd=Tcp_listen(NULL,argv[1],NULL);
}
else if (argc==3)
{
listenfd=Tcp_listen(argv[1],argv[2],NULL)
}
else
err_quit("useage: tcprecv [<host>] <port#>");
connfd=Accept(listenfd,NULL,NULL);
Signal(SIGURG,sig_urg);
Fcntl(connfd,F_SETOWN,getpid());
for (; ; )
{
if ((n=Read(connfd,buff,sizeof(buff)-1))==0)
{
printf("received EOF\n" );
exit(0);
}
buff[n]=0;
printf("read %d bytes:%s\n",n,buff );
}
return 0;
}
long
#else
int
#endif
__write (int fd, const void *buf, size_t size)
{
unsigned char c, *foo;
unsigned flags;
long r;
struct xattr statbuf;
_DOSTIME timebuf;
if (__mint == 0 && isatty(fd)) {
r = __OPEN_INDEX(fd);
if (r < 0 || r >= __NHANDLES)
r = __NHANDLES - 1;
flags = __open_stat[r].flags;
if ((flags & RAW) || _sig_handler[SIGINT] != SIG_DFL) {
foo = (unsigned char *) buf;
r = size;
while (r-- > 0) {
c = *foo++;
if (c == '\n' && (flags & CRMOD))
_console_write_byte(fd, '\r');
_console_write_byte(fd, c);
}
return size;
}
}
r = Fwrite(fd, size, buf);
if (r < 0) {
__set_errno (-r);
return -1;
}
if (size && r == 0) {
if (__mint >= 9)
{
if ((r = Fcntl (fd, &statbuf, FSTAT)) < 0)
{
__set_errno (-r);
return -1;
}
if (((mode_t) statbuf.st_mode & S_IFMT) == S_IFREG)
{
__set_errno (ENOSPC);
return -1;
}
}
else if (Fdatime (&timebuf, fd, 0) == 0
&& Fseek (0L, fd, SEEK_CUR) >= 0)
{
__set_errno (ENOSPC);
return -1;
}
}
return r;
}
int
__getpeername (int fd, struct sockaddr *addr, socklen_t *addrlen)
{
if (__libc_newsockets) {
long r = Fgetpeername (fd, addr, addrlen);
if (r != -ENOSYS) {
if (r < 0) {
__set_errno (-r);
return -1;
}
return 0;
} else
__libc_newsockets = 0;
}
{
struct getpeername_cmd cmd;
short addrlen16;
long r;
if (addrlen)
addrlen16 = (short) *addrlen;
cmd.cmd = GETPEERNAME_CMD;
cmd.addr = addr;
cmd.addrlen = &addrlen16;
r = Fcntl (fd, (long) &cmd, SOCKETCALL);
if (addrlen) {
size_t oaddrlen;
oaddrlen = *addrlen;
*addrlen = addrlen16;
/* XXX */
if (!__libc_unix_names && addr && addr->sa_family == AF_UNIX && r >= 0) {
struct sockaddr_un *unp = (struct sockaddr_un *) addr;
char name[sizeof (unp->sun_path)];
if (addrlen16 > UN_OFFSET) {
_dos2unx (unp->sun_path, name, PATH_MAX);
*addrlen = UN_OFFSET;
*addrlen += _sncpy (unp->sun_path, name, oaddrlen - UN_OFFSET);
}
}
}
if (r < 0) {
__set_errno (-r);
return -1;
}
return 0;
}
}
void
start_connect(struct file *fptr)
{
int fd, flags, n;
struct addrinfo *ai;
ai = Host_serv(fptr->f_host, SERV, 0, SOCK_STREAM);
fd = Socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
fptr->f_fd = fd;
printf("start_connect for %s, fd %d\n", fptr->f_name, fd);
/* 4Set socket nonblocking */
flags = Fcntl(fd, F_GETFL, 0);
Fcntl(fd, F_SETFL, flags | O_NONBLOCK);
/* 4Initiate nonblocking connect to the server. */
if ( (n = connect(fd, ai->ai_addr, ai->ai_addrlen)) < 0)
{
if (errno != EINPROGRESS)
err_sys("nonblocking connect error");
fptr->f_flags = F_CONNECTING;
//register
int ret = 0;
struct kevent changes[1];
EV_SET(&changes[0], fd, EVFILT_WRITE, EV_ADD, 0, 0, NULL);
ret = kevent(kq, changes, 1, NULL, 0, NULL);
if (ret < 0) {
err_sys("kevent()");
}
EV_SET(&changes[0], fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
ret = kevent(kq, changes, 1, NULL, 0, NULL);
if (fd > maxfd)
maxfd = fd;
}
else if (n >= 0) /* connect is already done */
{
write_get_cmd(fptr); /* write() the GET command */
}
}
void my_unlock(int fd)
{
struct flock lock;
lock.l_type = F_UNLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
Fcntl(fd, F_SETLK, &lock);
}
void my_lock(int fd)
{
struct flock lock;
lock.l_type = F_WRLCK;
lock.l_whence = SEEK_SET;
lock.l_start = 0;
lock.l_len = 0;
Fcntl(fd, F_SETLKW, &lock);
return ;
}
static void
relock(void)
{
struct flock l;
l.l_type = F_WRLCK;
l.l_whence = 1;
l.l_start = 0;
l.l_len = 0;
(void)Fcntl (lock_fd, F_SETLK, &l);
return;
}
int
http_request(domain_t * domain) {
int sockfd = Socket(AF_INET, SOCK_STREAM, 0);
int n;
int flags = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, flags | O_NONBLOCK);
ev_io_init(&domain->io, connect_handler, sockfd, EV_WRITE);
ev_io_start(domain->options->loop, &domain->io);
ev_timer_init(&domain->tw, timeout_handler, MAXCONTIME, 0);
ev_timer_start(domain->options->loop, &domain->tw);
if ((n = connect(sockfd, (struct sockaddr *) &domain->servaddr, sizeof (domain->servaddr))) < 0)
if (errno != EINPROGRESS)
return (-1);
return 0;
}
int
tcsetpgrp(int fd, pid_t pgrp)
{
long r;
long pg;
pg = (long) pgrp;
r = Fcntl((short) fd, (long) &pg, TIOCSPGRP);
if (r < 0) {
__set_errno ((int) -r);
return -1;
}
return 0;
}
void
heartbeat_cli(int servfd_arg, int nsec_arg, int maxnprobes_arg)
{
servfd = servfd_arg; /* set globals for signal handlers */
if ( (nsec = nsec_arg) < 1)
nsec = 1;
if ( (maxnprobes = maxnprobes_arg) < nsec)
maxnprobes = nsec;
nprobes = 0;
Signal(SIGURG, sig_urg);
Fcntl(servfd, F_SETOWN, getpid());
Signal(SIGALRM, sig_alrm);
alarm(nsec);
}
void sigio_dg_echo(int sockfd_arg, SA *pcliaddr, socklen_t clilen_arg)
{
int i;
const int on = 1;
sigset_t zeromask, newmask, oldmask;
sockfd = sockfd_arg;
clilen = clilen_arg;
for (i = 0; i < QSIZE; i++) { /* init queue of buffers */
dg[i].dg_data = Malloc(MAXDG);
dg[i].dg_sa = Malloc(clilen);
dg[i].dg_salen = clilen;
}
iget = iput = nqueue = 0;
Signal(SIGHUP, sig_hup);
Signal(SIGIO, sig_io);
Fcntl(sockfd, F_SETOWN, getpid());
if (ioctl(sockfd, FIOASYNC, &on) < 0)
err_sys("ioctl error");
if (ioctl(sockfd, FIONBIO, &on) < 0)
err_sys("ioctl error");
Sigemptyset(&zeromask);
Sigemptyset(&oldmask);
Sigemptyset(&newmask);
Sigaddset(&newmask, SIGIO); /* signal we want to block */
Sigprocmask(SIG_BLOCK, &newmask, &oldmask);
for (;;) {
while (nqueue == 0)
sigsuspend(&zeromask);
Sigprocmask(SIG_SETMASK, &oldmask, NULL);
Sendto(sockfd, dg[iget].dg_data, dg[iget].dg_len, 0,
dg[iget].dg_sa, dg[iget].dg_salen);
if (++iget >= QSIZE)
iget = 0;
/* Block SIGIO */
Sigprocmask(SIG_BLOCK, &newmask, &oldmask);
nqueue--;
}
}
int main(int meoww, char **pornn)
{
int cat; /*size*/
if(meoww == 2)
ListenMeow = tcp_listen(NULL, pornn[1], NULL);
else if(meoww == 3)
ListenMeow = tcp_listen(pornn[1], pornn[2], NULL);
else
err_quit("tcpreceive [<host>] <port#>");
cat = 4096;
SetSockopt(ListenMeow, SOL_SOCKET, SO_RCVBUF, &cat, sizeof(cat));
ConnectMeow = accept(ListenMeow, NULL, NULL);
Signal(SIGURG, sig_urg);
Fcntl(ConnectMeow, F_SETOWN, getpid());
for(; ;)
pause();
}
int
__recvmsg (int fd, struct msghdr *msg, int flags)
{
if (__libc_newsockets) {
long r = Frecvmsg (fd, msg, flags);
if (r != -ENOSYS) {
if (r < 0) {
__set_errno (-r);
return -1;
}
return r;
} else
__libc_newsockets = 0;
}
{
struct recvmsg_cmd cmd;
struct sockaddr_un *unp = (struct sockaddr_un *) msg->msg_name;
size_t oaddrlen = msg->msg_namelen;
long r;
cmd.cmd = RECVMSG_CMD;
cmd.msg = msg;
cmd.flags = flags;
r = Fcntl (fd, (long) &cmd, SOCKETCALL);
if (!__libc_unix_names && unp && unp->sun_family == AF_UNIX && r >= 0) {
char name[sizeof (unp->sun_path)];
if (msg->msg_namelen > UN_OFFSET) {
_dos2unx (unp->sun_path, name, PATH_MAX);
msg->msg_namelen = UN_OFFSET;
msg->msg_namelen += _sncpy (unp->sun_path, name, oaddrlen - UN_OFFSET);
}
}
if (r < 0) {
__set_errno (-r);
return -1;
}
return r;
}
}
int
main(int argc, char **argv)
{
int size;
if (argc == 2)
listenfd = Tcp_listen(NULL, argv[1], NULL);
else if (argc == 3)
listenfd = Tcp_listen(argv[1], argv[2], NULL);
else
err_quit("usage: tcprecv05 [ <host> ] <port#>");
size = 4096;
Setsockopt(listenfd, SOL_SOCKET, SO_RCVBUF, &size, sizeof(size));
connfd = Accept(listenfd, NULL, NULL);
Signal(SIGURG, sig_urg);
Fcntl(connfd, F_SETOWN, getpid());
for ( ; ; )
pause();
}
void str_cli(FILE * fd, int sockfd)
{
int maxfdp1, val, stdineof;
ssize_t n, nwritten;
fd_set rset, wset;
char to[MAXLINE], fr[MAXLINE];
char *toiptr, *tooptr, *friptr, *froptr;
val = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, val | O_NONBLOCK);
val = Fcntl(STDIN_FILENO, F_GETFL, 0);
Fcntl(STDIN_FILENO, F_SETFL, val | O_NONBLOCK);
val = Fcntl(STDOUT_FILENO, F_GETFL, 0);
Fcntl(STDOUT_FILENO, F_SETFL, val | O_NONBLOCK);
toiptr = tooptr = &to[MAXLINE];
friptr = froptr = &fr[MAXLINE];
stdineof = 0;
maxfdp1 = max(max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;
for(;;)
{
FD_ZERO(&rset);
FD_ZERO(&wset);
if(stdineof == 0 && toiptr < &to[MAXLINE])
FD_SET(STDIN_FILENO, &rset);
if( friptr < &fr[MAXLINE] )
FD_SET(STDOUT_FILENO, &rset);
if(toiptr != tooptr)
FD_SET(sockfd, &wset);
if(friptr != froptr)
FD_SET(STDOUT_FILENO, &wset);
Select(maxfdp1, &rset, &wset, NULL, NULL);
if (FD_ISSET(STDIN_FILENO, &rset))
{
if( (n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0)
{
if( errno != EWOULDBLOCK )
err_sys("read error on stdin");
}
else if(n == 0)
{
fprintf(stderr, "%s: EOF on stdin\n", gf_time());
stdineof = 1;
if (toiptr == tooptr)
Shutdown(sockfd, SHUT_WR);
}
else
{
fprintf(stderr, "%s: read %d bytes from stdin\n", gf_time(), n);
toiptr += n;
FD_SET(sockfd, &wset);
}
}
if(FD_ISSET(sockfd, &rset))
{
if( (n = read(STDOUT_FILENO, friptr, &fr[MAXLINE] - friptr)) < 0)
{
if( errno != EWOULDBLOCK )
err_sys("read error on socket");
}
else if(n == 0)
{
fprintf(stderr, "%s: EOF on stdin\n", gf_time());
if(stdineof)
return; /* normal termination */
else
err_quit("str_cli server terminated prematurely");
}
else
{
fprintf(stderr, "%s: read %d bytes from socket\n", gf_time(), n);
friptr += n;
FD_SET(STDOUT_FILENO, &wset);
}
}
if(FD_ISSET(STDOUT_FILENO, &wset) && ( n = (friptr - froptr)) > 0)
{
if( (nwritten= write(STDOUT_FILENO, froptr, n)) < 0)
{
if(errno != EWOULDBLOCK)
err_sys("write error to stdout");
}
else
{
fprintf(stderr, "%s: wrote %d bytes to stdout\n", gf_time(), nwritten);
froptr += n;
if(froptr == friptr)
froptr = friptr = fr;
}
}
if(FD_ISSET(sockfd, &wset) && ( n = (toiptr - tooptr)) > 0)
{
if( (nwritten= write(STDOUT_FILENO, froptr, n)) < 0)
{
if(errno != EWOULDBLOCK)
err_sys("write error to socket");
}
else
{
fprintf(stderr, "%s: wrote %d bytes to socket\n", gf_time(), nwritten);
tooptr += n;
if(tooptr == toiptr)
{
tooptr = toiptr = to;
if(stdineof)
Shutdown(sockfd, SHUT_WR);
}
}
}
}
}
int
open_direct(char *ptype, PRINTER *pp)
{
short bufsz = -1, cps = -1;
int open_mode, fd;
register unsigned int oldalarm, newalarm = 0;
char *device;
struct ecpp_transfer_parms ecpp_params; /* for ECPP port checking */
char **modules = NULL;
struct flock lck;
struct stat buf;
register void (*oldsig)() = signal(SIGALRM, sigalrm);
/*
* Set an alarm to wake us from trying to open the port.
* We'll try at least 60 seconds, or more if the printer
* has a huge buffer that, in the worst case, would take
* a long time to drain.
*/
tidbit(ptype, "bufsz", &bufsz);
tidbit(ptype, "cps", &cps);
if (bufsz > 0 && cps > 0)
newalarm = (((long)bufsz * 1100) / cps) / 1000;
if (newalarm < 60)
newalarm = 60;
oldalarm = alarm(newalarm);
device = pp->device;
if (is_printer_uri(device) == 0) {
/*
* if it's a device uri and the endpoint contains a valid
* path, that path should be opened/locked by lpsched for
* the backend. If not, the uri isn't associated with a
* local device, so use /dev/null.
*/
device = strstr(device, "://");
if (device != NULL)
device = strchr(device + 3, '/');
if ((device == NULL) || (access(device, F_OK) < 0))
device = "/dev/null";
}
/*
* The following open must be interruptable.
* O_APPEND is set in case the ``port'' is a file.
* O_RDWR is set in case the interface program wants
* to get input from the printer. Don't fail, though,
* just because we can't get read access.
*/
open_mode = O_WRONLY;
if (access(device, R_OK) == 0)
open_mode = O_RDWR;
open_mode |= O_APPEND;
SigAlrm = 0;
while ((fd = open(device, open_mode, 0)) == -1) {
if (errno != EINTR)
return (EXEC_EXIT_NPORT);
else if (SigAlrm)
return (EXEC_EXIT_TMOUT);
}
alarm(oldalarm);
signal(SIGALRM, oldsig);
/*
* Lock the file in case two "printers" are defined on the
* same port. Don't lock /dev/null.
*/
lck.l_type = F_WRLCK;
lck.l_whence = 0;
lck.l_start = 0L;
lck.l_len = 0L;
if (strcmp(device, "/dev/null") && Fcntl(fd, F_SETLKW, &lck) < 0) {
execlog("lock error: %s\n", pp->device);
return (EXEC_EXIT_NPORT);
}
/*
* We should get the correct channel number (1), but just
* in case....
*/
if (fd != 1) {
dup2(fd, 1);
Close(fd);
}
/*
* Handle streams modules:
*/
if (fstat(1, &buf))
buf.st_mode = 0;
/*
* for some unknown reason, lpsched appears to pop the streams
* modules off the device and push back some "default" ones,
* unless a specific set were specified with the printer configuration.
* This behaviour causes problems with the ECPP port, so if we have
* an ECPP port, and nobody specified a set of modules to use, we
* should leave it alone. Normally, we would not bother to play with
* the streams modules, but it is possible that someone has come
* to rely on this behaviour for other devices.
*/
if ((pp->modules != NULL) && (pp->modules[0] != NULL) &&
(strcmp(pp->modules[0], "default") != 0))
modules = pp->modules;
if ((modules == NULL) && (ioctl(1, ECPPIOC_GETPARMS, &ecpp_params) < 0))
modules = getlist(DEFMODULES, LP_WS, LP_SEP);
/* if "nopush" is supplied, leave the modules alone */
if ((modules != NULL) && (modules[0] != NULL) &&
(strcasecmp(modules[0], "nopush") == 0))
modules = NULL;
/*
* If we have a stream and a list of modules to use, then pop the old
* modules and push the new ones.
*/
if ((modules != NULL) && !S_ISFIFO(buf.st_mode) && isastream(1)) {
/*
* First, pop all current modules off, unless
* instructed not to.
*/
while (ioctl(1, I_POP, 0) == 0)
;
/*
* Now push either the administrator specified modules
* or the standard modules, unless instructed to push
* nothing.
*/
if ((modules[1] == NULL) &&
(strcasecmp(modules[0], "none") == 0))
return (0);
while (*modules)
if (push_module(1, device, *modules++) == -1)
return (EXEC_EXIT_NPUSH);
}
return (0);
}
TVerdict CTestSyscalls::doTestStepL()
{
int err;
if(TestStepName() == KCreat)
{
INFO_PRINTF1(_L("Creat():"));
err = Creat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen1)
{
INFO_PRINTF1(_L("open1():"));
err = open1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen2)
{
INFO_PRINTF1(_L("open2():"));
err = open2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen3)
{
INFO_PRINTF1(_L("open3():"));
err = open3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen4)
{
INFO_PRINTF1(_L("open4():"));
err = open4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen5)
{
INFO_PRINTF1(_L("open5():"));
err = open5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen6)
{
INFO_PRINTF1(_L("open6():"));
err = open6();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenTruncate1)
{
INFO_PRINTF1(_L("OpenTruncate1:"));
err = OpenTruncate1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenTruncate2)
{
INFO_PRINTF1(_L("OpenTruncate2:"));
err = OpenTruncate2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen7)
{
INFO_PRINTF1(_L("open7():"));
err = open7();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpenInAppendMode)
{
INFO_PRINTF1(_L("OpenInAppendMode():"));
err = OpenInAppendMode();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite1)
{
INFO_PRINTF1(_L("write1():"));
err = write1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite2)
{
INFO_PRINTF1(_L("write2():"));
err = write2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite3)
{
INFO_PRINTF1(_L("write3():"));
err = write3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kwrite5)
{
INFO_PRINTF1(_L("write5():"));
err = write5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread1)
{
INFO_PRINTF1(_L("read1():"));
err = read1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread2)
{
INFO_PRINTF1(_L("read2():"));
err = read2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread3)
{
INFO_PRINTF1(_L("read3():"));
err = read3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread4)
{
INFO_PRINTF1(_L("read4():"));
err = read4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpendir)
{
INFO_PRINTF1(_L("Opendir():"));
err = Opendir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClosedir)
{
INFO_PRINTF1(_L("Closedir():"));
err = Closedir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReaddir)
{
INFO_PRINTF1(_L("Readdir():"));
err = Readdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseek)
{
INFO_PRINTF1(_L("Lseek():"));
err = Lseek();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseek1)
{
INFO_PRINTF1(_L("Lseek1():"));
err = Lseek1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KAccess)
{
INFO_PRINTF1(_L("Access():"));
err = Access();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KAccess1)
{
INFO_PRINTF1(_L("Access1():"));
err = Access1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KDup)
{
INFO_PRINTF1(_L("Dup():"));
err = Dup();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KDup2)
{
INFO_PRINTF1(_L("Dup2():"));
err = Dup2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename)
{
INFO_PRINTF1(_L("Rename():"));
err = Rename();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename1)
{
INFO_PRINTF1(_L("Rename1():"));
err = Rename1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod)
{
INFO_PRINTF1(_L("Chmod():"));
err = Chmod();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod1)
{
INFO_PRINTF1(_L("Chmod1():"));
err = Chmod1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod_dir)
{
INFO_PRINTF1(_L("Chmod_dir():"));
err = Chmod_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFChmod)
{
INFO_PRINTF1(_L("FChmod():"));
err = FChmod();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFChmod_dir)
{
INFO_PRINTF1(_L("FChmod_dir():"));
err = FChmod_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KExit)
{
INFO_PRINTF1(_L("Exit():"));
err = Exit();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClose)
{
INFO_PRINTF1(_L("Close():"));
err = Close();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir)
{
INFO_PRINTF1(_L("Mkdir():"));
err = Mkdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMk_dir)
{
INFO_PRINTF1(_L("Mk_dir():"));
err = Mk_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir)
{
INFO_PRINTF1(_L("Rmdir():"));
err = Rmdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRm_dir)
{
INFO_PRINTF1(_L("Rm_dir():"));
err = Rm_dir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir1)
{
INFO_PRINTF1(_L("Rmdir1():"));
err = Rmdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir_Chdir)
{
INFO_PRINTF1(_L("Rmdir_Chdir():"));
err = Rmdir_Chdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFsync)
{
INFO_PRINTF1(_L("Fsync():"));
err = Fsync();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes)
{
INFO_PRINTF1(_L("Utimes():"));
err = Utimes();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtime)
{
INFO_PRINTF1(_L("Utime():"));
err = Utime();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir)
{
INFO_PRINTF1(_L("Chdir():"));
err = Chdir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFcntl)
{
INFO_PRINTF1(_L("Fcntl():"));
err = Fcntl();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KIoctl)
{
INFO_PRINTF1(_L("Ioctl():"));
err = Ioctl();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFstat)
{
INFO_PRINTF1(_L("Fstat():"));
err = Fstat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat)
{
INFO_PRINTF1(_L("Stat():"));
err = Stat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat1)
{
INFO_PRINTF1(_L("Stat1():"));
err = Stat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat2)
{
INFO_PRINTF1(_L("Stat2():"));
err = Stat2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat3)
{
INFO_PRINTF1(_L("Stat3():"));
err = Stat3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KGetpid)
{
INFO_PRINTF1(_L("Getpid():"));
err = Getpid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KClock)
{
INFO_PRINTF1(_L("Clock():"));
err = Clock();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTime)
{
INFO_PRINTF1(_L("Time():"));
err = Time();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaitPid)
{
INFO_PRINTF1(_L("WaitPid():"));
err = WaitPid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReadV)
{
INFO_PRINTF1(_L("ReadV():"));
err = ReadV();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWriteV)
{
INFO_PRINTF1(_L("WriteV():"));
err = WriteV();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KSleep)
{
INFO_PRINTF1(_L("Sleep():"));
err = Sleep();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KSeekDir)
{
INFO_PRINTF1(_L("SeekDir():"));
err = SeekDir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRewindDir)
{
INFO_PRINTF1(_L("RewindDir():"));
err = RewindDir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTelldir)
{
INFO_PRINTF1(_L("Telldir():"));
err = Telldir();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTestClock)
{
INFO_PRINTF1(_L("TestClock():"));
err = TestClock();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KCreat2)
{
INFO_PRINTF1(_L("Creat2():"));
err = Creat2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopen8)
{
INFO_PRINTF1(_L("open8():"));
err = open8();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KTestStat)
{
INFO_PRINTF1(_L("KTestStat():"));
err = TestStat();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseekttytest1)
{
INFO_PRINTF1(_L("Lseekttytest1():"));
err = Lseekttytest1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KLseekttytest2)
{
INFO_PRINTF1(_L("Lseekttytest2():"));
err = Lseekttytest2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaitPidtest)
{
INFO_PRINTF1(_L("WaitPidtest():"));
err = WaitPidtest();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KWaittest)
{
INFO_PRINTF1(_L("Waittest():"));
err = Waittest();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KOpen_FileDes_Test)
{
INFO_PRINTF1(_L("Open_FileDes_Test():"));
err = Open_FileDes_Test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kopenuid)
{
INFO_PRINTF1(_L("openuid():"));
err = openuid();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir1)
{
INFO_PRINTF1(_L("Mkdir1():"));
err = Mkdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir2)
{
INFO_PRINTF1(_L("Mkdir2():"));
err = Mkdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename2)
{
INFO_PRINTF1(_L("Rename2():"));
err = Rename2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestfsync)
{
INFO_PRINTF1(_L("testfsync():"));
err = testfsync();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestrename)
{
INFO_PRINTF1(_L("testrename():"));
err = testrename();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ktestopenvalidate)
{
INFO_PRINTF1(_L("testopenvalidate():"));
err = testopenvalidate();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Ksync_safe)
{
INFO_PRINTF1(_L("sync_safe():"));
err = sync_safe();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KFstat1)
{
INFO_PRINTF1(_L("Fstat1():"));
err = Fstat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes1)
{
INFO_PRINTF1(_L("Utimes1():"));
err = Utimes1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir_test1)
{
INFO_PRINTF1(_L("Mkdir_test1():"));
err = Mkdir_test1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod_test)
{
INFO_PRINTF1(_L("Chmod_test():"));
err = Chmod_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir1)
{
INFO_PRINTF1(_L("Chdir1():"));
err = Chdir1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir2)
{
INFO_PRINTF1(_L("Rmdir2():"));
err = Rmdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename_test)
{
INFO_PRINTF1(_L("Rename_test():"));
err = Rename_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename3)
{
INFO_PRINTF1(_L("Rename3():"));
err = Rename3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KCreat1)
{
INFO_PRINTF1(_L("Creat1():"));
err = Creat1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KReadV1)
{
INFO_PRINTF1(_L("ReadV1():"));
err = ReadV1();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KUtimes2)
{
INFO_PRINTF1(_L("Utimes2():"));
err = Utimes2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KStat_test)
{
INFO_PRINTF1(_L("Stat_test():"));
err = Stat_test();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KMkdir_test2)
{
INFO_PRINTF1(_L("Mkdir_test2():"));
err = Mkdir_test2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChmod2)
{
INFO_PRINTF1(_L("Chmod2():"));
err = Chmod2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KChdir2)
{
INFO_PRINTF1(_L("Chdir2():"));
err = Chdir2();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename4)
{
INFO_PRINTF1(_L("Rename4():"));
err = Rename4();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRename5)
{
INFO_PRINTF1(_L("Rename5():"));
err = Rename5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == KRmdir3)
{
INFO_PRINTF1(_L("Rmdir3():"));
err = Rmdir3();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
else if(TestStepName() == Kread5)
{
INFO_PRINTF1(_L("read5():"));
err = read5();
SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);
}
return TestStepResult();
}
int
dg_client(int sfd, const SA* pSA, socklen_t len)
{
int var = Fcntl(sfd, F_GETFL, 0);
Fcntl(sfd, F_SETFL, var | O_NONBLOCK);
int s;
int efd;
struct epoll_event *events;
struct epoll_event event;
event.data.fd = sfd;
event.events = EPOLLIN | EPOLLET;
efd = epoll_create1(0);
if (efd == -1) {
perror("epoll_create");
abort();
}
s = epoll_ctl(efd, EPOLL_CTL_ADD, sfd, &event);
if (s == -1) {
perror("epoll_ctl");
abort();
}
/* Buffer where events are returned */
events = (epoll_event *)calloc(MAXEVENTS, sizeof event);
for (;;) {
int n, j;
n = epoll_wait(efd, events, MAXEVENTS, 0);
int done = 0;
char buf[512];
if ( Fgets(buf, sizeof buf, stdin)) {
ssize_t count = sendto(sfd, buf, strlen (buf), 0, pSA, len );
if (count == -1) {
if (errno != EAGAIN) {
perror("sendto");
}
} else if (count == 0) {
}
}
for (j = 0; j < n; j++) {
if ((events[j].events & EPOLLERR) ||
(events[j].events & EPOLLHUP)
) {
/* An error has occured on this fd, or the socket is not
ready for reading (why were we notified then?) */
// close(events[i].data.fd);
continue;
} else if (sfd == events[j].data.fd) {
if (events[j].events & EPOLLIN) {
/* We have data on the fd waiting to be read. Read and
display it. We must read whatever data is available
completely, as we are running in edge-triggered mode
and won't get a notification again for the same
data. */
int done = 0;
while (1) {
ssize_t count;
char buf[512];
count = recvfrom(events[j].data.fd, buf, sizeof buf, 0 ,0 , 0);
if (count == -1) {
/* If errno == EAGAIN, that means we have read all
data. So go back to the main loop. */
if (errno != EAGAIN) {
perror("read");
}
break;
} else if (count == 0) {
/* End of file. The remote has closed the
connection. */
break;
}
// jia handle read
buf[count] = 0;
Fputs(buf, stdout);
}
}
}
}
}
free(events);
close(sfd);
return EXIT_SUCCESS;
}
void
str_cli(FILE *fp, int sockfd)
{
int maxfdp1, val, stdineof;
ssize_t n, nwritten;
fd_set rset, wset;
char to[MAXLINE], fr[MAXLINE];
char *toiptr, *tooptr, *friptr, *froptr;
val = Fcntl(sockfd, F_GETFL, 0);
Fcntl(sockfd, F_SETFL, val | O_NONBLOCK);
val = Fcntl(STDIN_FILENO, F_GETFL, 0);
Fcntl(STDIN_FILENO, F_SETFL, val | O_NONBLOCK);
val = Fcntl(STDOUT_FILENO, F_GETFL, 0);
Fcntl(STDOUT_FILENO, F_SETFL, val | O_NONBLOCK);
toiptr = tooptr = to; /* initialize buffer pointers */
friptr = froptr = fr;
stdineof = 0;
maxfdp1 = max(max(STDIN_FILENO, STDOUT_FILENO), sockfd) + 1;
for ( ; ; ) {
FD_ZERO(&rset);
FD_ZERO(&wset);
if (stdineof == 0 && toiptr < &to[MAXLINE])
FD_SET(STDIN_FILENO, &rset); /* read from stdin */
if (friptr < &fr[MAXLINE])
FD_SET(sockfd, &rset); /* read from socket */
if (tooptr != toiptr)
FD_SET(sockfd, &wset); /* data to write to socket */
if (froptr != friptr)
FD_SET(STDOUT_FILENO, &wset); /* data to write to stdout */
Select(maxfdp1, &rset, &wset, NULL, NULL);
/* end nonb1 */
/* include nonb2 */
if (FD_ISSET(STDIN_FILENO, &rset)) {
if ( (n = read(STDIN_FILENO, toiptr, &to[MAXLINE] - toiptr)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("read error on stdin");
} else if (n == 0) {
#ifdef VOL2
fprintf(stderr, "%s: EOF on stdin\n", gf_time());
#endif
stdineof = 1; /* all done with stdin */
if (tooptr == toiptr)
Shutdown(sockfd, SHUT_WR);/* send FIN */
} else {
#ifdef VOL2
fprintf(stderr, "%s: read %d bytes from stdin\n", gf_time(), n);
#endif
toiptr += n; /* # just read */
FD_SET(sockfd, &wset); /* try and write to socket below */
}
}
if (FD_ISSET(sockfd, &rset)) {
if ( (n = read(sockfd, friptr, &fr[MAXLINE] - friptr)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("read error on socket");
} else if (n == 0) {
#ifdef VOL2
fprintf(stderr, "%s: EOF on socket\n", gf_time());
#endif
if (stdineof)
return; /* normal termination */
else
err_quit("str_cli: server terminated prematurely");
} else {
#ifdef VOL2
fprintf(stderr, "%s: read %d bytes from socket\n",
gf_time(), n);
#endif
friptr += n; /* # just read */
FD_SET(STDOUT_FILENO, &wset); /* try and write below */
}
}
/* end nonb2 */
/* include nonb3 */
if (FD_ISSET(STDOUT_FILENO, &wset) && ( (n = friptr - froptr) > 0)) {
if ( (nwritten = write(STDOUT_FILENO, froptr, n)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("write error to stdout");
} else {
#ifdef VOL2
fprintf(stderr, "%s: wrote %d bytes to stdout\n",
gf_time(), nwritten);
#endif
froptr += nwritten; /* # just written */
if (froptr == friptr)
froptr = friptr = fr; /* back to beginning of buffer */
}
}
if (FD_ISSET(sockfd, &wset) && ( (n = toiptr - tooptr) > 0)) {
if ( (nwritten = write(sockfd, tooptr, n)) < 0) {
if (errno != EWOULDBLOCK)
err_sys("write error to socket");
} else {
#ifdef VOL2
fprintf(stderr, "%s: wrote %d bytes to socket\n",
gf_time(), nwritten);
#endif
tooptr += nwritten; /* # just written */
if (tooptr == toiptr) {
toiptr = tooptr = to; /* back to beginning of buffer */
if (stdineof)
Shutdown(sockfd, SHUT_WR); /* send FIN */
}
}
}
}
}
int main(int argc, char ** argv){
int i, maxi, maxfd, listenfd, connfd, sockfd,val,nwritten;
int nready, client[NUMBEROFSTATIONS];
ssize_t n;
fd_set rset, allrset, wset,allwset;
socklen_t clilen;
struct sockaddr_in cliaddr, servaddr;
int frame_number;
int source_station_number;
int destination_sockfd; //used to assign destination station socket number,
char *message1; //used to store first message
char *message2; //used to store second message
char source[INET_ADDRSTRLEN]; //used to the third parameter of function inet_ntop
char *sourceIP; //used to stored IP address of SP
/* dest is an array that will store the destination station numbers
and their corresponding socket descriptors. This will later be used to
send frame to destination station after receiving both messages of frame */
char *destinationIP;
char *destination_addr;
int stored_destination_number;
struct destination dest[NUMBEROFSTATIONS];
/* initilize each station's sockfd to -1 */
for (i = 0; i < NUMBEROFSTATIONS; i++){
(dest + i)->destination_sockfd = -1;
}
struct frame * receiving_framePtr;
struct cbp_storage cbs;
char col_mes[COLLISIONMESSAGE] = "Collision";
char *collision_message = col_mes;
listenfd = Socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);
Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));
Listen(listenfd, LISTENQ);
maxfd = listenfd; /* initialize */
maxi = -1; /* index into client[] array */
/* Set to non-blocking mode using Fcntl for non-blocking IO*/
/* Set socket descriptor that write to CBP output */
val = Fcntl(fileno(stdout), F_GETFL, 0);
Fcntl(fileno(stdout), F_SETFL, val | O_NONBLOCK);
val = Fcntl(fileno(stdin), F_GETFL, 0);
Fcntl(fileno(stdin), F_SETFL, val | O_NONBLOCK);
for (i = 0; i < NUMBEROFSTATIONS; i++)
client[i] = -1; /* -1 indicates available entry */
FD_ZERO(&allrset);
FD_ZERO(&allwset);
FD_SET(listenfd, &allrset);
maxfd = listenfd;
int ctClient = 0;
for ( ;; ) {
rset = allrset;
//wset = allwset;/* structure assignment */
nready = Select(maxfd+1, &rset, NULL, NULL, NULL);
if (ctClient == NUMBEROFSTATIONS){
if (FD_ISSET(listenfd, &rset)) { /* new client connection */
clilen = sizeof(cliaddr);
connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);
printf("New connection, sockfd: %d\n",connfd);
/* Save the just-connected station, e.i. its socket descriptor and its station number
This information will later be used to send frame to destination station after
receiving both message of frame */
destinationIP = Inet_ntop(AF_INET, &cliaddr.sin_addr,source,INET_ADDRSTRLEN);
stored_destination_number = ston(destinationIP);
for (i = 0; i < NUMBEROFSTATIONS; i++){
if((dest+i)->destination_sockfd < 0){
(dest+i)->destination_sockfd = connfd;
(dest+i)->destination_station_number = stored_destination_number;
break;
}
}
/* Set socket descriptor to and from SP using Fcntl for non-blocking IO*/
val = Fcntl(connfd, F_GETFL, 0);
Fcntl(connfd, F_SETFL, val | O_NONBLOCK);
for (i = 0; i < NUMBEROFSTATIONS; i++)
if (client[i] < 0) {
client[i] = connfd;
ctClient++;
break;
}
FD_SET(connfd, &allrset);
FD_SET(connfd, &allwset);
if (connfd > maxfd)
maxfd = connfd;
if (i > maxi)
maxi = i;
if (--nready <= 0)
continue;
}
else //Clients full
{
break;
}
}
}
/*All Sps are now connect to the CBP, ready for sending frames*/
/*buffer_acquired is set to: 0 when first part of frame received 1 when the second part of the frame sent, making the buffer ready for new frame
or when a collision happens, discards the remaining part of the frame, allows stations to acquire the CBP storage
*/
char response;
printf("All stations are connected, ready to exchage data (Y/N): \n");
scanf("%*c %c",&response);
if( (response == 'y') || (response == 'Y') ){
int buffer_acquired = 1;
for( ; ; ){
nready = Select(maxfd+1, &rset, &wset, NULL, NULL);
for (i = 0; i <= maxi; i++) { /* check all clients for data */
sockfd = client[i];
FD_SET(sockfd, &rset);
sourceIP = Inet_ntop(AF_INET, &cliaddr.sin_addr,source,INET_ADDRSTRLEN);
source_station_number = ston(sourceIP);
if(buffer_acquired){
if(FD_ISSET(sockfd, &rset)){
buffer_acquired = 0;
if(n = Read(sockfd, receiving_framePtr,MAXLINE) == 0){
Close(sockfd);
FD_CLR(sockfd,&allrset);
client[i] = -1;
}
else{
/* Get information from struct frame type variable pointed by receiving_framePtr pointer
that is received from SP */
frame_number = receiving_framePtr->frame_number;
message1 = receiving_framePtr->message1;
destination_addr = receiving_framePtr->destination_addr;
int destination_station_number = ston(destination_addr);
//inspect the message1
cbs.source_station_sd = sockfd;
cbs.source_station_number = source_station_number;
cbs.destination_station_number = destination_station_number;
cbs.frame_number = frame_number;
strcpy(cbs.message1,message1);
/*Turn on the bit to write to stdout*/
FD_SET(fileno(stdout), &wset);
if(FD_ISSET(fileno(stdout), &wset))
fprintf(stdout,"Receive %s of frame %d from Station %d,to Station %d\n",
message1,frame_number,source_station_number,destination_station_number);
}
if (--nready <= 0)
break; /* no more readable descriptors */
}
}
else{
/* Buffer already store first message of a frame of a station
Check if the receiving message is the second frame of that frame or
the first message of a frame from another station */
if (FD_ISSET(sockfd, &rset)){
if(n = Read(sockfd, receiving_framePtr,MAXLINE) == 0){
Close(sockfd);
FD_CLR(sockfd,&allrset);
client[i] = -1;
}
else{/* Inspect the message if it is the second message
or the first message from another frame of another station*/
/* Get information from struct frame type variable pointed by receiving_framePtr pointer
that is received from SP */
frame_number = receiving_framePtr->frame_number; //get frame number
message2 = receiving_framePtr->message2; //get the second message
destination_addr = receiving_framePtr->destination_addr; //get the destination address (string)
int destination_station_number = ston(destination_addr); //convert to number using ston function
//Inspect the message
//Check if the current source station number is the one whose first message has already been saved to CBP storage
//If yes, save the second message
if(cbs.source_station_number == source_station_number &&
cbs.frame_number == frame_number){
if(strcmp(message2,"part 2"==0)){
strcpy(cbs.message2,message2);
/*Turn on the bit to write to stdout*/
FD_SET(fileno(stdout), &wset);
if(FD_ISSET(fileno(stdout), &wset))
fprintf(stdout,"Receive %s of frame %d from Station %d,to Station %d\n",
message1,frame_number,source_station_number,destination_station_number);
/* Turn on the bit in the wset to write to desination station the first message
Get the destination socket number from the dest array
*/
for( i = 0; i<NUMBEROFSTATIONS; i++){
if((dest+i)->destination_station_number == cbs.destination_station_number)
break;
}
destination_sockfd = (dest+i)->destination_sockfd;
FD_SET(destination_sockfd, &wset);
}
}
else{ /* Receiving frame from another station, inform both station a collision*/
/* Sending collision message to station that accquired the bus, discards the remaing parts of frame */
buffer_acquired = 1;
FD_SET(cbs.source_station_sd, &wset);
if(FD_ISSET(cbs.source_station_sd, &wset))
Writen(cbs.source_station_sd, collision_message, strlen(COLLISIONMESSAGE));
/*Sending collision message to another station*/
if(FD_ISSET(sockfd, &wset))
Writen(sockfd, collision_message, strlen(COLLISIONMESSAGE));
}
}
if (--nready <= 0)
break; /* no more readable descriptors */
}
}
/* Sending the first message of the frame to destinaition SP*/
}
}
}
}
